From 5e5c35bbccc22bab3b3b5e4fd037475547264f9b Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 10:35:51 +0800 Subject: [PATCH 001/165] plan: define Panel Tier-1 Stage B diagnostics contracts --- .../panel_p1_stage_b_diagnostics_plan.md | 495 ++++++++++++++++++ 1 file changed, 495 insertions(+) create mode 100644 dev/plans/panel_p1_stage_b_diagnostics_plan.md diff --git a/dev/plans/panel_p1_stage_b_diagnostics_plan.md b/dev/plans/panel_p1_stage_b_diagnostics_plan.md new file mode 100644 index 000000000..457db0947 --- /dev/null +++ b/dev/plans/panel_p1_stage_b_diagnostics_plan.md @@ -0,0 +1,495 @@ +# Panel Tier-1 Stage B — diagnostics and fit-statistics plan + +Issue: #93 +Stage-A base: PR #119 / merge commit `e9e0ec43b8b2cfcd7600013a60cb02100c72f4f5` +Branch: `agent/panel-p1-stage-b-diagnostics` + +## 1. Scope and impact classification + +Stage B adds the user-visible specification tests and fit statistics promised by Issue #93 while preserving the Stage-A estimator transformations, coefficient estimates, covariance definitions, prediction contracts, and strict-device rules. + +Active impact axes: + +- **Public API** — new structured diagnostic functions/results and new fitted-statistics attributes. +- **Inference** — Hausman, pooling F, Breusch–Pagan LM, model F statistics, p-values, and degrees of freedom. +- **Backend** — all sufficient-statistic accumulation must work on NumPy, CuPy, and Torch without explicit-device fallback. +- **Formula** — diagnostic metadata and sample identity must remain aligned after Patsy missing-row filtering. +- **Docs/artifacts** — EN/CN model docs, changelogs, external-definition matrix, and physical-GPU evidence. + +Inactive gates: + +- **Loss / penalty / solver / CV** — Stage B does not modify an optimization objective, regularization, solver, or tuning path. +- **Performance benchmark** — no speedup claim is planned. A physical runner is a correctness/provenance gate, not a timing benchmark. Any material memory/performance regression discovered during review reactivates this gate. + +Validation target: `remote-full` before Stage B is called COMPLETE. + +## 2. Capability decisions + +| Model / capability | backend | inference | formula | Stage-B diagnostics / fit stats | +| --- | --- | --- | --- | --- | +| `PanelOLS` | three-backend | supported | supported | pooling F; standard within/between/overall R²; adjusted R²; classical model F; Hausman input | +| `RandomEffects` | three-backend | supported | supported | within/between/overall R²; adjusted R²; classical model F; Hausman input | +| `PooledOLS` | three-backend | supported | supported | overall R² always; within/between R² and BP-LM when `entity_ids` supplied; adjusted R²; classical model F | +| `BetweenOLS` | three-backend | supported | supported | within/between/overall R²; adjusted R²; classical model F | +| `FirstDifferenceOLS` | three-backend | supported | supported | within/between/overall R²; adjusted R² on differenced fit basis; classical model F | +| `FamaMacBeth` | three-backend | supported | supported | overall R² always; within/between R² only if optional `entity_ids` supplied; no residual-OLS model F is synthesized from the beta-series covariance | + +`FamaMacBeth` remains a special covariance/inference family. Stage B must not route it through residual OLS sandwich or claim that a pooled-OLS F statistic is its beta-series joint significance test. + +## 3. External definition matrix + +Stage B will record and test against the following definitions. External packages are references, not authorities that override statgpu's existing estimator contracts. + +### 3.1 Parameter-based R² + +Primary alignment: `linearmodels` 7.0. + +Reference: + +- https://bashtage.github.io/linearmodels/panel/faq.html +- https://bashtage.github.io/linearmodels/panel/mathematical-formula.html + +`linearmodels` explicitly distinguishes parameter-based R² from correlation-based measures used by some other software. Stage B adopts the parameter-based family because it evaluates the actual estimated coefficient vector. + +For unweighted data and a fitted coefficient vector `beta`: + +- **Overall**: residual `e_o = y - X beta`; center `y` only when the corresponding level equation has an intercept/implicit constant; `R²_o = 1 - SSE_o / TSS_o`. +- **Between**: form entity means `y_bar_i`, `X_bar_i`; residual `e_b = y_bar - X_bar beta`; center the between response when the level equation has an intercept/implicit constant; `R²_b = 1 - SSE_b / TSS_b`. +- **Within**: entity-demean `y` and `X`; `e_w = y_within - X_within beta`; `R²_w = 1 - SSE_w / TSS_w`. + +Important compatibility rule: Stage A froze the existing public `PanelOLS.rsquared_within`. For two-way FE that legacy attribute is computed on the full entity+time transformed fit, whereas the standard `linearmodels` `rsquared_within` is entity-within. **Stage B must not silently change the legacy attribute.** The new `fit_statistics_.rsquared_within` is the explicitly documented standard entity-within measure; metadata records `legacy_rsquared_within` when the existing attribute differs (notably two-way FE). For one-way entity FE the two coincide up to numerical tolerance. + +### 3.2 Classical model F statistic + +Primary alignment: `linearmodels.PanelResults.f_statistic`. + +Reference: + +- https://bashtage.github.io/linearmodels/panel/panel/linearmodels.panel.results.PanelResults.f_statistic.html + +For a model fit in its estimator-specific estimation space: + +`F = ((RSS_R - RSS_U) / q) / (RSS_U / df_resid)` + +where the restriction sets all estimable non-constant slope coefficients to zero, `q` is the effective number of tested slopes, and `df_resid` is the model's established residual degrees of freedom. + +Stage B's `PanelFitStatistics.f_statistic` is the **classical homoskedastic model F**. It does not silently turn into a robust Wald statistic when `cov_type='robust'` or `'clustered'`. Robust Wald/model tests are a separate contract and are not added in Stage B. + +Estimator fit spaces: + +- `PooledOLS`: pooled level design including its intercept. +- `PanelOLS`: the existing effect-transformed design and current absorbed-effect residual df. +- `RandomEffects`: the existing quasi-demeaned GLS design. +- `BetweenOLS`: entity-mean regression. +- `FirstDifferenceOLS`: first-difference regression. +- `FamaMacBeth`: do not manufacture a residual-OLS F statistic; beta-series joint Wald inference may be a later explicitly named capability. + +### 3.3 Pooling F / fixed-effect significance test + +Primary alignment: `linearmodels.PanelEffectsResults.f_pooled` and `plm::pFtest`. + +References: + +- https://bashtage.github.io/linearmodels/panel/panel/linearmodels.panel.results.PanelEffectsResults.f_pooled.html +- https://rdrr.io/cran/plm/man/pFtest.html +- https://rdrr.io/cran/plm/src/R/test_general.R + +For the same aligned estimation sample and regressors: + +`F_pool = ((RSS_pool - RSS_FE) / df_num) / (RSS_FE / df_resid_FE)` + +with + +`df_num = df_resid_pool - df_resid_FE`. + +This df-difference definition is preferred to hard-coding `N-1`, `T-1`, or `N+T-2`, because it automatically respects the actual effective pooled design rank and Stage-A absorbed-effect residual df. In ordinary full-rank one-way FE it reduces to the standard effect-count df. + +Contract: + +- only `PanelOLS` fits with at least one included effect are applicable; +- pooling comparison is recomputed internally on the same post-formula/post-missing-data sample during `PanelOLS.fit()`; users do not have to fit a second `PooledOLS` object; +- the test is classical/homoskedastic, matching the external definitions; covariance type does not change the RSS-based statistic; +- null: all included fixed effects are jointly zero; +- alternative: at least one included effect is nonzero; +- distribution: `F(df_num, df_resid_FE)`. + +Numerical nesting checks: + +- if `RSS_pool - RSS_FE >= 0`, use it directly; +- if the difference is negative only within a scale-aware floating-point tolerance, normalize it to zero and record `metadata['roundoff_normalized']=True`; +- a materially negative difference indicates a violated nesting/rank contract and returns `applicable=False` with an explicit reason; it is never silently clipped into a valid-looking positive statistic. + +### 3.4 Breusch–Pagan LM for entity random effects + +Primary alignment: `plm::plmtest(type='bp', effect='individual')`, including the Baltagi–Li unbalanced-panel version. + +References: + +- https://rdrr.io/cran/plm/man/plmtest.html +- https://rdrr.io/cran/plm/src/R/test_general.R + +The test uses **pooled-OLS residuals**. Let `e_it` be pooled residuals, `n` the number of observations, and `T_i` the observation count of entity `i`: + +`CP = sum_it e_it^2` + +`A1 = sum_i (sum_t e_it)^2 / CP - 1` + +`M11 = sum_i T_i^2` + +`LM1 = n * sqrt(1 / (2 * (M11 - n))) * A1` + +`LM_BP = LM1^2 ~ chi2(1)`. + +This formula applies to balanced and unbalanced panels and matches the current `plm` implementation attributed to Baltagi and Li (1990) for incomplete panels. + +Stage-B scope is **one-way entity BP-LM** because statgpu's current `RandomEffects` is one-way entity RE. A two-way BP statistic would test a broader error-components model that statgpu does not currently estimate and is not exposed under the RE-vs-pooled diagnostic name in this PR. + +Contract: + +- add optional `entity_ids=None` to `PooledOLS.fit()`; existing calls remain unchanged; +- when entity IDs are supplied, formula row filtering aligns them through the existing side-array machinery; +- pooled residual group sums and counts are accumulated on the selected backend during fit; full numerical residual arrays are not copied to CPU for the test; +- null: entity random-effect variance is zero (pooled OLS sufficient); +- alternative: a nonzero entity random-effect component is present; +- distribution: `chi2(1)`; +- require at least two entities, positive pooled residual sum of squares, and `M11 > n`; otherwise return an inapplicable structured result with the exact reason. + +The name/documentation must distinguish this panel error-components BP-LM from the cross-sectional heteroskedasticity Breusch–Pagan test. + +### 3.5 Classical Hausman FE-vs-RE + +Primary alignment: Hausman (1978), `plm::phtest` original quadratic-form method, and Stata `hausman`. + +References: + +- https://rdrr.io/cran/plm/man/phtest.html +- https://rdrr.io/cran/plm/src/R/test_general.R +- https://www.stata.com/manuals/rhausman.pdf + +For common non-intercept coefficients: + +`d = beta_FE - beta_RE` + +`D = V_FE - V_RE` + +`H = d' D^{-1} d ~ chi2(q)` + +where `q` is the effective rank of the covariance-difference restriction space. + +Stage-B applicability is deliberately stricter than a blind matrix solve: + +- `fe_model` must be a fitted `PanelOLS` with `entity_effects=True` and `time_effects=False`; +- `re_model` must be a fitted `RandomEffects`; +- both models must represent the same aligned estimation sample and common slope design; +- the original quadratic-form test is available only for the current **classical/nonrobust** covariance pair. A robust/clustered FE covariance is not relabeled as a robust Hausman test. `plm` documents robustification through an auxiliary-regression Hausman variant, which is outside Stage B; +- intercepts are excluded, following `plm` and Stata; common slope names/order are matched explicitly; +- no common estimable slope => inapplicable. + +Covariance-difference handling: + +1. symmetrize `D` numerically as `(D + D.T)/2` on the small final matrix; +2. compute an eigenvalue/rank tolerance scaled by matrix norm and machine epsilon; +3. if an eigenvalue is materially negative, return `applicable=False` with reason `covariance difference is not positive semidefinite`; do **not** force a statistic by absolute values or eigenvalue clipping; +4. if `D` is positive semidefinite but rank-deficient, use a Moore–Penrose inverse on the identified range and set chi-square df to `rank(D)`, but only if `d` lies in the column space within tolerance; record `metadata['used_pinv']=True` and the numerical rank; +5. if `d` has a material component in the null space, return inapplicable rather than pretending the unidentified direction contributes zero; +6. a computed statistic slightly below zero only from roundoff may be normalized to zero with metadata; a materially negative statistic is inapplicable. + +This makes singular/indefinite behavior explicit as required by Issue #93 and avoids generic linear-algebra exceptions. + +## 4. Public API proposal + +### 4.1 Result objects + +Keep the Stage-A frozen dataclasses and make them public through `statgpu.panel` and top-level `statgpu`: + +- `PanelTestResult` +- `PanelFitStatistics` + +`PanelTestResult` fields remain: + +- `statistic` +- `pvalue` +- `distribution` +- `df` +- `null` +- `alternative` +- `applicable` +- `reason` +- `metadata` + +No exception is used for an econometrically inapplicable but otherwise well-formed diagnostic. Programming errors (wrong object type, unfitted object when a fitted model is required, malformed metadata length) remain exceptions. + +### 4.2 Diagnostic functions + +Add public functions in `statgpu.panel._diagnostics` and export them from `statgpu.panel` and top-level `statgpu`: + +```python +hausman_test(fe_model: PanelOLS, re_model: RandomEffects) -> PanelTestResult +pooling_f_test(fe_model: PanelOLS) -> PanelTestResult +breusch_pagan_lm_test(pooled_model: PooledOLS) -> PanelTestResult +``` + +These functions consume fitted model state/sufficient statistics. They do not accept arbitrary covariance matrices as a pseudo-public escape hatch in Stage B. + +Convenience estimator methods may delegate exactly to these functions: + +```python +fe.pooling_f_test() +fe.hausman_test(re) +pooled.breusch_pagan_lm_test() +``` + +If methods are added, there must be one implementation source of truth in `_diagnostics.py`; methods are thin delegates only. + +### 4.3 Fit statistics + +After every supported fit, expose: + +```python +model.fit_statistics_: PanelFitStatistics +``` + +with standard fields: + +- `rsquared_within` +- `rsquared_between` +- `rsquared_overall` +- `rsquared_adj` +- `f_statistic` +- `f_pvalue` +- `f_df` +- `metadata` + +`metadata` must identify the R² convention and estimator-specific adjusted-R² basis, and give explicit reasons for unavailable fields. + +Do not rename/remove the existing `PanelOLS.rsquared_within` or estimator-specific `rsquared` attributes in Stage B. + +## 5. Internal architecture + +### 5.1 Shared diagnostics helpers + +Create `statgpu/panel/_diagnostics.py` for: + +- construction of applicable/inapplicable `PanelTestResult` objects; +- parameter-based within/between/overall R² sufficient-statistic helpers; +- adjusted-R² helper; +- classical model-F helper; +- pooling-F helper; +- BP-LM helper; +- Hausman small-matrix comparison and applicability logic. + +Core observation-scale operations take `xp` and backend arrays. Only final scalars, small `k x k` covariance matrices, feature names, and index metadata may be converted to NumPy. + +### 5.2 Covariance persistence + +`BasePanelModel._panel_store_ols_inference()` already returns `cov_params`. Stage B will persist the final small covariance matrix on fitted inference-capable estimators as `cov_params_` in a consistent public CPU ndarray contract, while preserving all existing `bse_/tvalues_/pvalues_/conf_int_` values. + +The conversion is limited to `k x k`; no full design or residual matrix is copied to host merely for Hausman. + +`FamaMacBeth` already stores `cov_params_` backend-native. Its existing output contract should not be silently changed solely for Hausman, since FMB is not a Hausman input. Any broader covariance-output normalization is separate work unless review finds it necessary for an existing public contract. + +### 5.3 Sample/design identity for Hausman + +Add small immutable diagnostic metadata to FE/RE fits sufficient to verify compatibility without retaining the full input data on CPU: + +- `nobs`; +- aligned entity codes/counts or a deterministic hash/signature of the aligned entity label sequence; +- aligned retained-row signature for formula fits; +- feature-name sequence after formula/model-matrix construction; +- numeric design width; +- intercept-presence metadata; +- effect specification. + +For raw array fits without formula names, deterministic positional slope names (`x1`, `x2`, ...) are used for matching. Same `nobs` alone is never treated as proof that the samples match. + +If a safe sample identity cannot be established for two independently fitted raw-array models, `hausman_test` returns `applicable=False` with a reason asking for matched identifiers rather than guessing. + +### 5.4 R² accumulation + +Compute R² variants during `fit()` while backend numerical arrays are available, then store only scalar results. Do not retain a second full copy of `X`/`y` for later diagnostics. + +For estimators where the model coefficient includes an explicit intercept, use the existing design convention to determine centering. For FE, standard R² variants use the level slope vector and the level/entity-demeaned data as defined above; fixed effects themselves are not inserted into overall/between predictions. + +For `PooledOLS` and `FamaMacBeth`, add optional `entity_ids=None` to `fit()` only to unlock panel decomposition metrics; coefficient estimates are unchanged. Absence of IDs leaves within/between fields as `None` with reasons in metadata. + +### 5.5 Adjusted R² + +Use an explicit residual-variance / total-variance definition on each estimator's **primary fit space**: + +`R²_adj = 1 - (RSS / df_resid) / (TSS / df_total)`. + +`df_total` is the effective total-sum-of-squares df in that fit space: + +- centered fit with an identified constant / implicit absorbed mean: `n_fit - 1`; +- uncentered fit with no constant: `n_fit`. + +For FE, `n_fit` is the number of retained observations while `df_resid` remains the established Stage-A residual df including absorbed effects. For BetweenOLS, `n_fit` is the number of entity means; for FirstDifferenceOLS, the number of retained first differences; for RE, the quasi-demeaned sample size; for PooledOLS, pooled sample size. + +`metadata['rsquared_adj_basis']` records `fit_space`, `df_total`, and `df_resid` so the convention is auditable. + +FamaMacBeth is not assigned this residual-OLS adjusted R²; its average period adjusted R² is a distinct statistic in some software and is not silently put into `PanelFitStatistics.rsquared_adj` without a separate explicit contract. + +## 6. Edge-case and failure contracts + +Tests must cover at least: + +- unfitted models passed to diagnostic functions; +- wrong estimator types; +- FE model with no effects passed to pooling F; +- time-only/two-way FE passed to one-way FE-vs-RE Hausman; +- FE robust/clustered covariance passed to classical Hausman; +- same shapes but mismatched samples/entity ordering in Hausman; +- no common slope coefficients; +- singular PSD Hausman covariance difference with identified `d`; +- singular PSD difference with `d` outside the identified range; +- materially indefinite covariance difference; +- roundoff-level negative Hausman/pooling quantities versus materially negative violations; +- BP-LM with one entity, singleton-only entities, zero pooled RSS, and unbalanced panels; +- constant outcome / zero TSS R² behavior; +- rank-deficient pooled design using effective rank; +- formula missing-row alignment for IDs; +- explicit CUDA/Torch request with unavailable backend must fail rather than fall back. + +For undefined R² due zero TSS, use `NaN` for a mathematically undefined numeric ratio and explain the reason in metadata; do not convert undefined values to 0 merely for presentation. + +## 7. Test plan + +### 7.1 Analytic unit tests + +Add `dev/tests/test_panel_stage_b_diagnostics.py` with deterministic small panels and hand-computed sufficient statistics for: + +- pooling F formula and df; +- balanced and unbalanced entity BP-LM; +- full-rank Hausman quadratic form; +- singular/indefinite Hausman applicability behavior; +- parameter-based within/between/overall R²; +- adjusted R² basis; +- classical model F. + +### 7.2 Existing-estimator regression + +Extend the Stage-A golden suite or add a Stage-B compatibility file to assert that Stage B does not change existing: + +- coefficients; +- bse/t/p/CI; +- predictions; +- existing `rsquared` / legacy `PanelOLS.rsquared_within` values; +- RE variance components/theta; +- FMB beta-series covariance. + +### 7.3 Three-backend parity + +For every new observation-scale statistic, compare NumPy/CuPy/Torch results on the same deterministic balanced and unbalanced panels. + +Hosted optional-backend tests may use existing CPU-compatible Torch coverage, but physical CuPy/Torch CUDA remains the final backend acceptance gate. + +Target numeric parity unless an external implementation uses a different estimator definition: + +- deterministic analytic/backend parity: `rtol <= 5e-8`, `atol <= 5e-9` by default; +- external model-statistics comparisons: tighter where definitions are identical, with any relaxed tolerance justified per field. + +### 7.4 Formula tests + +Cover: + +- explicit/implicit intercept behavior; +- categorical terms and interactions already supported by panel formula parsing; +- missing-row alignment of `entity_ids`/`time_ids`; +- effect tokens for PanelOLS; +- diagnostics computed from exactly the retained estimation sample. + +### 7.5 External alignment + +Add a reproducible external-comparison script/artifact that records definitions rather than just numbers. + +Python `linearmodels` comparisons: + +- PanelOLS one-way and two-way: coefficients, standard R² variants, classical model F, pooled F; +- PooledOLS, BetweenOLS, FirstDifferenceOLS, RandomEffects: R² variants and model F where definitions/parameterization match; +- note any Swamy-Arora parameterization difference before comparing RE quantities. + +R `plm` comparisons: + +- `pFtest(within, pooling)`; +- `plmtest(pooling, type='bp', effect='individual')` on balanced and unbalanced panels; +- `phtest(within, random)` for a well-conditioned classical Hausman example. + +Stata is documentation/reference-only unless a licensed callable environment is available. Record its Hausman formula/interpretation, not unverifiable claimed numeric parity. + +## 8. Physical GPU acceptance + +Add `dev/benchmarks/validate_panel_stage_b_gpu.py` as a correctness/provenance runner. + +Requirements: + +- exact expected SHA; +- clean working tree; +- requested backend must actually execute (`cupy` / CUDA Torch); +- balanced and unbalanced data; +- compare new fit statistics and diagnostics against NumPy references; +- include at least PanelOLS pooling F, PooledOLS BP-LM, FE/RE Hausman prerequisites, R² variants, adjusted R², and model F; +- record environment/package/GPU provenance and max absolute differences in JSON. + +No performance claim is made from this runner. + +## 9. Documentation plan + +Update, in EN-first / CN-follow order: + +- panel model documentation covering `PanelOLS`, `RandomEffects`, `PooledOLS`, and shared diagnostics; +- model/index capability table if present; +- root `CHANGELOG.md`; +- `docs/en/changelog.md`; +- `docs/cn/changelog.md`. + +Documentation must explicitly state: + +- parameter-based versus correlation-based R²; +- the preserved legacy `PanelOLS.rsquared_within` compatibility distinction for two-way FE; +- classical/homoskedastic nature of model F and pooling F; +- BP-LM is the panel error-components test, not the heteroskedasticity BP test; +- classical Hausman restrictions and explicit singular/indefinite behavior; +- which statistics are unavailable without entity IDs; +- three-backend/no-silent-fallback behavior. + +## 10. Implementation sequence and gates + +1. **Plan review gate** — audit this document against Issue #93, Stage-A contracts, external definitions, and repo workflow. Fix all HIGH and relevant MEDIUM findings before source edits. +2. **Result/API substrate** — export Stage-A result dataclasses; add `_diagnostics.py`; define applicability helpers and public exports. +3. **Sufficient-statistic helpers** — R²/model-F/pooling-F/BP helpers with NumPy tests first, written backend-generically from the start. +4. **Estimator integration** — persist small covariance matrices; populate `fit_statistics_`; compute pooling/BP contexts during fit; add optional entity metadata where required without changing coefficients. +5. **Hausman integration** — sample/design identity, common-coefficient matching, PSD/rank logic. +6. **Three-backend targeted tests** — NumPy/CuPy/Torch parity and strict-device failure behavior. +7. **External Python/R alignment** — run strongest available local baselines; if R unavailable locally, retain exact script/command and mark only that external gate remote-pending. +8. **Full hosted CI** — complete test suite, Python matrix, static/docs, maintenance, release-package/front-end gates as applicable. +9. **Physical GPU** — exact clean-head CuPy/Torch runner. +10. **Auto-fix review loop** — fresh code review after evidence; no unresolved CRITICAL/HIGH/in-scope MEDIUM findings before promotion. +11. **Docs/changelog sync** — no user-visible capability advertised before tests and definitions are final. + +## 11. Explicit non-goals for Stage B + +- robust/auxiliary-regression Hausman test; +- two-way random effects or two-way BP-LM as an RE-vs-pooled selector; +- RandomEffects robust covariance; +- HC0/HC2/HC3 expansion; +- Driscoll–Kraay; +- cluster small-sample expansion; +- FamaMacBeth residual-OLS covariance or residual-OLS model F; +- changing Stage-A estimator coefficients, covariance normalizations, prediction behavior, or legacy R² attributes. + +These remain Stage C or later work unless a blocking correctness dependency is discovered. + +## 12. Completion criteria + +Stage B can be called COMPLETE only when: + +- the three public diagnostic tests return structured `PanelTestResult` objects with documented applicability behavior; +- `fit_statistics_` is populated consistently where defined; +- existing numerical estimator behavior remains frozen by regression tests; +- all new observation-scale operations have NumPy/CuPy/Torch parity with no silent fallback; +- linearmodels/plm definition alignment is recorded and tested where callable; +- formula/missing-row alignment is covered; +- hosted CI passes on the final exact head; +- physical CuPy/Torch evidence passes on the final exact clean head; +- fresh review has no unresolved CRITICAL, HIGH, or in-scope MEDIUM findings; +- EN/CN docs and all three changelogs are synchronized. From a23533ea54231e8a2d292df45870946b646d45ba Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 10:39:40 +0800 Subject: [PATCH 002/165] plan: tighten Panel Stage B diagnostic contracts --- .../panel_p1_stage_b_diagnostics_plan.md | 103 +++++++++++------- 1 file changed, 66 insertions(+), 37 deletions(-) diff --git a/dev/plans/panel_p1_stage_b_diagnostics_plan.md b/dev/plans/panel_p1_stage_b_diagnostics_plan.md index 457db0947..5e03a83f0 100644 --- a/dev/plans/panel_p1_stage_b_diagnostics_plan.md +++ b/dev/plans/panel_p1_stage_b_diagnostics_plan.md @@ -44,19 +44,22 @@ Stage B will record and test against the following definitions. External package Primary alignment: `linearmodels` 7.0. -Reference: +References: - https://bashtage.github.io/linearmodels/panel/faq.html - https://bashtage.github.io/linearmodels/panel/mathematical-formula.html +- https://bashtage.github.io/linearmodels/_modules/linearmodels/panel/model.html `linearmodels` explicitly distinguishes parameter-based R² from correlation-based measures used by some other software. Stage B adopts the parameter-based family because it evaluates the actual estimated coefficient vector. For unweighted data and a fitted coefficient vector `beta`: -- **Overall**: residual `e_o = y - X beta`; center `y` only when the corresponding level equation has an intercept/implicit constant; `R²_o = 1 - SSE_o / TSS_o`. -- **Between**: form entity means `y_bar_i`, `X_bar_i`; residual `e_b = y_bar - X_bar beta`; center the between response when the level equation has an intercept/implicit constant; `R²_b = 1 - SSE_b / TSS_b`. +- **Overall**: residual `e_o = y - X beta`; center `y` only when the corresponding level equation has an identified explicit/implicit constant; `R²_o = 1 - SSE_o / TSS_o`. +- **Between**: form entity means `y_bar_i`, `X_bar_i`; residual `e_b = y_bar - X_bar beta`; center the between response when the corresponding level equation has an identified explicit/implicit constant; `R²_b = 1 - SSE_b / TSS_b`. - **Within**: entity-demean `y` and `X`; `e_w = y_within - X_within beta`; `R²_w = 1 - SSE_w / TSS_w`. +For the new standardized `fit_statistics_` fields, a zero total sum of squares follows the `linearmodels` convention and reports `0.0`, with `metadata['degenerate_total_ss'][] = True`. Stage B does **not** rewrite legacy estimator attributes that already have another degenerate-TSS behavior; those remain frozen for compatibility. + Important compatibility rule: Stage A froze the existing public `PanelOLS.rsquared_within`. For two-way FE that legacy attribute is computed on the full entity+time transformed fit, whereas the standard `linearmodels` `rsquared_within` is entity-within. **Stage B must not silently change the legacy attribute.** The new `fit_statistics_.rsquared_within` is the explicitly documented standard entity-within measure; metadata records `legacy_rsquared_within` when the existing attribute differs (notably two-way FE). For one-way entity FE the two coincide up to numerical tolerance. ### 3.2 Classical model F statistic @@ -71,7 +74,7 @@ For a model fit in its estimator-specific estimation space: `F = ((RSS_R - RSS_U) / q) / (RSS_U / df_resid)` -where the restriction sets all estimable non-constant slope coefficients to zero, `q` is the effective number of tested slopes, and `df_resid` is the model's established residual degrees of freedom. +where the restriction sets all estimable non-constant slope coefficients to zero, `q` is the **effective restriction rank** (`rank_unrestricted - rank_restricted`, not blindly the raw column count), and `df_resid` is the model's established residual degrees of freedom. Stage B's `PanelFitStatistics.f_statistic` is the **classical homoskedastic model F**. It does not silently turn into a robust Wald statistic when `cov_type='robust'` or `'clustered'`. Robust Wald/model tests are a separate contract and are not added in Stage B. @@ -84,6 +87,8 @@ Estimator fit spaces: - `FirstDifferenceOLS`: first-difference regression. - `FamaMacBeth`: do not manufacture a residual-OLS F statistic; beta-series joint Wald inference may be a later explicitly named capability. +If there are no estimable non-constant restrictions, the F field is unavailable with an explicit metadata reason rather than dividing by zero. + ### 3.3 Pooling F / fixed-effect significance test Primary alignment: `linearmodels.PanelEffectsResults.f_pooled` and `plm::pFtest`. @@ -91,18 +96,20 @@ Primary alignment: `linearmodels.PanelEffectsResults.f_pooled` and `plm::pFtest` References: - https://bashtage.github.io/linearmodels/panel/panel/linearmodels.panel.results.PanelEffectsResults.f_pooled.html +- https://bashtage.github.io/linearmodels/_modules/linearmodels/panel/model.html - https://rdrr.io/cran/plm/man/pFtest.html - https://rdrr.io/cran/plm/src/R/test_general.R For the same aligned estimation sample and regressors: -`F_pool = ((RSS_pool - RSS_FE) / df_num) / (RSS_FE / df_resid_FE)` +`F_pool = ((RSS_pool - RSS_FE) / df_num) / (RSS_FE / df_resid_FE)`. -with +The restricted pooled model must be constructed with the **same constant convention as the FE model's nested null**, including the no-explicit-constant correction used by `linearmodels`: -`df_num = df_resid_pool - df_resid_FE`. +- when the level design contains an identified explicit constant, fit the pooled regression with that level design; +- when the FE specification has effects but no explicit constant column, project both pooled `y` and pooled `X` off the common constant before the pooled slope fit, and reduce the effect-test numerator df by one. This prevents the common mean from being incorrectly counted as a tested fixed effect. -This df-difference definition is preferred to hard-coding `N-1`, `T-1`, or `N+T-2`, because it automatically respects the actual effective pooled design rank and Stage-A absorbed-effect residual df. In ordinary full-rank one-way FE it reduces to the standard effect-count df. +The primary numerator-df calculation is the nested-model rank/df difference, equivalent to `df_resid_pool - df_resid_FE` after the constant correction. The implementation records both effective ranks and the final df in metadata; it never hard-codes `N-1`, `T-1`, or `N+T-2`. Contract: @@ -149,6 +156,7 @@ Contract: - add optional `entity_ids=None` to `PooledOLS.fit()`; existing calls remain unchanged; - when entity IDs are supplied, formula row filtering aligns them through the existing side-array machinery; - pooled residual group sums and counts are accumulated on the selected backend during fit; full numerical residual arrays are not copied to CPU for the test; +- if `cov_type='hac'` and `time_index` causes a stable numerical row reorder, the aligned `entity_ids` diagnostic codes are reordered by the **same** permutation before any residual grouping, R² accumulation, or sample fingerprinting; diagnostic metadata may never remain in pre-sort order while X/y are post-sort; - null: entity random-effect variance is zero (pooled OLS sufficient); - alternative: a nonzero entity random-effect component is present; - distribution: `chi2(1)`; @@ -172,9 +180,7 @@ For common non-intercept coefficients: `D = V_FE - V_RE` -`H = d' D^{-1} d ~ chi2(q)` - -where `q` is the effective rank of the covariance-difference restriction space. +`H = d' D^{-1} d ~ chi2(q)` for full-rank `D`. Stage-B applicability is deliberately stricter than a blind matrix solve: @@ -190,9 +196,10 @@ Covariance-difference handling: 1. symmetrize `D` numerically as `(D + D.T)/2` on the small final matrix; 2. compute an eigenvalue/rank tolerance scaled by matrix norm and machine epsilon; 3. if an eigenvalue is materially negative, return `applicable=False` with reason `covariance difference is not positive semidefinite`; do **not** force a statistic by absolute values or eigenvalue clipping; -4. if `D` is positive semidefinite but rank-deficient, use a Moore–Penrose inverse on the identified range and set chi-square df to `rank(D)`, but only if `d` lies in the column space within tolerance; record `metadata['used_pinv']=True` and the numerical rank; -5. if `d` has a material component in the null space, return inapplicable rather than pretending the unidentified direction contributes zero; -6. a computed statistic slightly below zero only from roundoff may be normalized to zero with metadata; a materially negative statistic is inapplicable. +4. if `D` is positive semidefinite but rank-deficient, statgpu may use a Moore–Penrose inverse on the identified range and set chi-square df to `rank(D)`, but only if `d` lies in the column space within tolerance; record `metadata['used_pinv']=True`, numerical rank, tolerance, and `metadata['definition_extension']='singular PSD generalized-inverse Hausman'`; +5. this singular-PSD generalized-inverse case is a documented statgpu extension to the ordinary full-rank `plm`/Stata path, not claimed as byte-for-byte external behavior; +6. if `d` has a material component in the null space, return inapplicable rather than pretending the unidentified direction contributes zero; +7. a computed statistic slightly below zero only from roundoff may be normalized to zero with metadata; a materially negative statistic is inapplicable. This makes singular/indefinite behavior explicit as required by Issue #93 and avoids generic linear-algebra exceptions. @@ -276,33 +283,38 @@ Create `statgpu/panel/_diagnostics.py` for: - classical model-F helper; - pooling-F helper; - BP-LM helper; -- Hausman small-matrix comparison and applicability logic. +- Hausman small-matrix comparison and applicability logic; +- compact backend-native sample/design fingerprint construction. -Core observation-scale operations take `xp` and backend arrays. Only final scalars, small `k x k` covariance matrices, feature names, and index metadata may be converted to NumPy. +Core observation-scale operations take `xp` and backend arrays. Only final scalars, O(k) numerical fingerprint components, small `k x k` covariance matrices, feature names, and index metadata may be converted to NumPy. ### 5.2 Covariance persistence -`BasePanelModel._panel_store_ols_inference()` already returns `cov_params`. Stage B will persist the final small covariance matrix on fitted inference-capable estimators as `cov_params_` in a consistent public CPU ndarray contract, while preserving all existing `bse_/tvalues_/pvalues_/conf_int_` values. +`BasePanelModel._panel_store_ols_inference()` already returns `cov_params`. Stage B stores the final small covariance matrix needed by diagnostics as an **internal** CPU ndarray (for example `_panel_cov_params`) on FE/RE and other relevant OLS-style models while preserving all existing `bse_/tvalues_/pvalues_/conf_int_` values. -The conversion is limited to `k x k`; no full design or residual matrix is copied to host merely for Hausman. +Do not create a new universal public `cov_params_` contract merely to implement Hausman. `FamaMacBeth.cov_params_` is an existing estimator-specific attribute and remains unchanged. -`FamaMacBeth` already stores `cov_params_` backend-native. Its existing output contract should not be silently changed solely for Hausman, since FMB is not a Hausman input. Any broader covariance-output normalization is separate work unless review finds it necessary for an existing public contract. +The conversion is limited to `k x k`; no full design or residual matrix is copied to host merely for Hausman. ### 5.3 Sample/design identity for Hausman -Add small immutable diagnostic metadata to FE/RE fits sufficient to verify compatibility without retaining the full input data on CPU: +FE/RE fits store compact immutable diagnostic metadata sufficient to reject mismatched samples/designs without retaining a full second host copy of X/y. + +Identity components: - `nobs`; -- aligned entity codes/counts or a deterministic hash/signature of the aligned entity label sequence; -- aligned retained-row signature for formula fits; +- aligned entity label/code sequence signature and entity counts; +- aligned retained-row signature for formula fits when available; - feature-name sequence after formula/model-matrix construction; -- numeric design width; -- intercept-presence metadata; -- effect specification. +- numeric design width and intercept-presence metadata; +- effect specification; +- a **backend-native numerical fingerprint** of aligned `X`, `y`, and row order, reduced on the selected backend to O(k) scalars before host conversion. + +The numerical fingerprint must include multiple independent deterministic moments, e.g. per-column/y sum, sum of squares, and an index-weighted first moment (using a deterministic row weight sequence), all accumulated in float64. It is an integrity check rather than a cryptographic hash. Comparison uses a scale-aware floating-point tolerance so the same float64 data on NumPy/CuPy/Torch are accepted while materially different samples/designs are rejected. -For raw array fits without formula names, deterministic positional slope names (`x1`, `x2`, ...) are used for matching. Same `nobs` alone is never treated as proof that the samples match. +For raw array fits without formula names, deterministic positional slope names (`x1`, `x2`, ...) are used for coefficient matching **in addition to** the numerical fingerprint. Same `nobs`, entity counts, or shape alone is never treated as proof that the samples match. -If a safe sample identity cannot be established for two independently fitted raw-array models, `hausman_test` returns `applicable=False` with a reason asking for matched identifiers rather than guessing. +If identity metadata are missing or disagree materially, `hausman_test` returns `applicable=False` with the precise mismatch reason rather than guessing. ### 5.4 R² accumulation @@ -312,6 +324,8 @@ For estimators where the model coefficient includes an explicit intercept, use t For `PooledOLS` and `FamaMacBeth`, add optional `entity_ids=None` to `fit()` only to unlock panel decomposition metrics; coefficient estimates are unchanged. Absence of IDs leaves within/between fields as `None` with reasons in metadata. +Any estimator-specific row reorder (currently notably PooledOLS HAC time sorting and FirstDifference sorting/differencing) must carry diagnostic metadata through the exact same permutation/transform before sufficient statistics are accumulated. + ### 5.5 Adjusted R² Use an explicit residual-variance / total-variance definition on each estimator's **primary fit space**: @@ -338,27 +352,27 @@ Tests must cover at least: - FE model with no effects passed to pooling F; - time-only/two-way FE passed to one-way FE-vs-RE Hausman; - FE robust/clustered covariance passed to classical Hausman; -- same shapes but mismatched samples/entity ordering in Hausman; +- same shapes/entity counts but materially mismatched X/y samples in Hausman; +- same data across NumPy/CuPy/Torch accepted by fingerprint tolerance; - no common slope coefficients; - singular PSD Hausman covariance difference with identified `d`; - singular PSD difference with `d` outside the identified range; - materially indefinite covariance difference; - roundoff-level negative Hausman/pooling quantities versus materially negative violations; - BP-LM with one entity, singleton-only entities, zero pooled RSS, and unbalanced panels; -- constant outcome / zero TSS R² behavior; -- rank-deficient pooled design using effective rank; +- PooledOLS HAC sorting with unsorted `time_index` and entity IDs, proving X/y/entity diagnostic alignment after sorting; +- constant outcome / zero TSS standardized R² behavior (`0.0` plus degenerate metadata) while legacy attributes remain unchanged; +- rank-deficient pooled design using effective restriction rank; - formula missing-row alignment for IDs; - explicit CUDA/Torch request with unavailable backend must fail rather than fall back. -For undefined R² due zero TSS, use `NaN` for a mathematically undefined numeric ratio and explain the reason in metadata; do not convert undefined values to 0 merely for presentation. - ## 7. Test plan ### 7.1 Analytic unit tests Add `dev/tests/test_panel_stage_b_diagnostics.py` with deterministic small panels and hand-computed sufficient statistics for: -- pooling F formula and df; +- pooling F formula, no-explicit-constant correction, and df; - balanced and unbalanced entity BP-LM; - full-rank Hausman quadratic form; - singular/indefinite Hausman applicability behavior; @@ -414,6 +428,8 @@ R `plm` comparisons: - `plmtest(pooling, type='bp', effect='individual')` on balanced and unbalanced panels; - `phtest(within, random)` for a well-conditioned classical Hausman example. +For the singular-PSD generalized-inverse Hausman extension, use an analytic matrix fixture rather than claiming `plm`/Stata parity. + Stata is documentation/reference-only unless a licensed callable environment is available. Record its Hausman formula/interpretation, not unverifiable claimed numeric parity. ## 8. Physical GPU acceptance @@ -428,6 +444,7 @@ Requirements: - balanced and unbalanced data; - compare new fit statistics and diagnostics against NumPy references; - include at least PanelOLS pooling F, PooledOLS BP-LM, FE/RE Hausman prerequisites, R² variants, adjusted R², and model F; +- include an unsorted-HAC PooledOLS case with entity IDs to guard metadata permutation; - record environment/package/GPU provenance and max absolute differences in JSON. No performance claim is made from this runner. @@ -445,10 +462,13 @@ Update, in EN-first / CN-follow order: Documentation must explicitly state: - parameter-based versus correlation-based R²; +- standardized zero-TSS behavior and preservation of legacy attributes; - the preserved legacy `PanelOLS.rsquared_within` compatibility distinction for two-way FE; - classical/homoskedastic nature of model F and pooling F; +- pooling-F implicit-constant correction; - BP-LM is the panel error-components test, not the heteroskedasticity BP test; -- classical Hausman restrictions and explicit singular/indefinite behavior; +- classical Hausman restrictions, data-identity checks, and explicit singular/indefinite behavior; +- the generalized-inverse singular-PSD Hausman case is a statgpu extension with rank df; - which statistics are unavailable without entity IDs; - three-backend/no-silent-fallback behavior. @@ -457,8 +477,8 @@ Documentation must explicitly state: 1. **Plan review gate** — audit this document against Issue #93, Stage-A contracts, external definitions, and repo workflow. Fix all HIGH and relevant MEDIUM findings before source edits. 2. **Result/API substrate** — export Stage-A result dataclasses; add `_diagnostics.py`; define applicability helpers and public exports. 3. **Sufficient-statistic helpers** — R²/model-F/pooling-F/BP helpers with NumPy tests first, written backend-generically from the start. -4. **Estimator integration** — persist small covariance matrices; populate `fit_statistics_`; compute pooling/BP contexts during fit; add optional entity metadata where required without changing coefficients. -5. **Hausman integration** — sample/design identity, common-coefficient matching, PSD/rank logic. +4. **Estimator integration** — persist small internal covariance matrices; populate `fit_statistics_`; compute pooling/BP contexts during fit; add optional entity metadata where required without changing coefficients; propagate every numerical row transform to diagnostics metadata. +5. **Hausman integration** — numerical sample/design fingerprints, common-coefficient matching, PSD/rank logic. 6. **Three-backend targeted tests** — NumPy/CuPy/Torch parity and strict-device failure behavior. 7. **External Python/R alignment** — run strongest available local baselines; if R unavailable locally, retain exact script/command and mark only that external gate remote-pending. 8. **Full hosted CI** — complete test suite, Python matrix, static/docs, maintenance, release-package/front-end gates as applicable. @@ -479,7 +499,16 @@ Documentation must explicitly state: These remain Stage C or later work unless a blocking correctness dependency is discovered. -## 12. Completion criteria +## 12. Plan-review findings closed before implementation + +- **[HIGH][INFER] fixed** — pooling F now specifies the implicit-common-constant correction and corresponding numerator-df decrement when the FE design lacks an explicit constant, matching the nested linearmodels definition. +- **[HIGH][API/INFER] fixed** — Hausman sample compatibility no longer relies on `nobs`/entity order alone; the plan requires a backend-native O(k) numerical X/y/order fingerprint. +- **[HIGH][BACKEND] fixed** — PooledOLS HAC sorting must apply the identical permutation to entity diagnostic metadata before BP/R²/fingerprint accumulation. +- **[MEDIUM][INFER] fixed** — standardized fit-stat R² adopts linearmodels' zero-TSS `0.0` convention with explicit degenerate metadata while preserving existing legacy attributes. +- **[MEDIUM][API] fixed** — Hausman only needs an internal small covariance matrix; Stage B will not create a new universal public `cov_params_` contract. +- **[MEDIUM][INFER] fixed** — singular-PSD generalized-inverse Hausman behavior is labeled explicitly as a statgpu extension and validated analytically rather than presented as direct plm/Stata parity. + +## 13. Completion criteria Stage B can be called COMPLETE only when: From fc38ff9be51c70e77765a252a1865fc131a4d2a1 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 10:44:17 +0800 Subject: [PATCH 003/165] feat: add shared Panel Stage B diagnostic primitives --- statgpu/panel/_diagnostics.py | 745 ++++++++++++++++++++++++++++++++++ 1 file changed, 745 insertions(+) create mode 100644 statgpu/panel/_diagnostics.py diff --git a/statgpu/panel/_diagnostics.py b/statgpu/panel/_diagnostics.py new file mode 100644 index 000000000..54ca03e90 --- /dev/null +++ b/statgpu/panel/_diagnostics.py @@ -0,0 +1,745 @@ +"""Shared Panel Tier-1 diagnostics and fit-statistic primitives. + +Stage B of Issue #93 adds structured specification tests and parameter-based +fit statistics without changing the Stage-A estimator transformations or +covariance definitions. Observation-scale accumulation stays on the selected +NumPy/CuPy/Torch backend; public diagnostic results contain only CPU scalars +and small metadata. +""" + +from __future__ import annotations + +import hashlib +from typing import Any, Dict, Optional, Sequence, Tuple + +import numpy as np + +from statgpu.backends import _to_float_scalar, _to_numpy, xp_asarray +from statgpu.inference._distributions_backend import get_distribution +from statgpu.panel._results import PanelFitStatistics, PanelTestResult +from statgpu.panel._utils import group_means + +__all__ = [ + "hausman_test", + "pooling_f_test", + "breusch_pagan_lm_test", +] + + +def _inapplicable( + *, + null: str, + alternative: str, + distribution: Optional[str], + reason: str, + df=None, + metadata: Optional[Dict[str, Any]] = None, +) -> PanelTestResult: + return PanelTestResult( + statistic=None, + pvalue=None, + distribution=distribution, + df=df, + null=null, + alternative=alternative, + applicable=False, + reason=str(reason), + metadata={} if metadata is None else dict(metadata), + ) + + +def _applicable( + statistic: float, + pvalue: float, + *, + null: str, + alternative: str, + distribution: str, + df, + metadata: Optional[Dict[str, Any]] = None, +) -> PanelTestResult: + return PanelTestResult( + statistic=float(statistic), + pvalue=float(pvalue), + distribution=distribution, + df=df, + null=null, + alternative=alternative, + applicable=True, + reason=None, + metadata={} if metadata is None else dict(metadata), + ) + + +def _matrix_rank(X, xp) -> int: + return int(_to_float_scalar(xp.linalg.matrix_rank(X))) + + +def _safe_r2(ss_res: float, ss_tot: float) -> Tuple[float, bool]: + """Return linearmodels-style parameter R² and a degenerate-TSS flag.""" + ss_res = float(ss_res) + ss_tot = float(ss_tot) + if ss_tot <= 0.0: + return 0.0, True + return 1.0 - ss_res / ss_tot, False + + +def _demean_matrix(X, entity_codes, xp): + out = X.clone() if getattr(xp, "__name__", "") == "torch" else X.copy() + for j in range(int(X.shape[1])): + out[:, j] = X[:, j] - group_means(X[:, j], entity_codes, xp=xp) + return out + + +def _first_group_indices(entity_codes, xp, ref_arr): + codes_np = np.asarray(_to_numpy(entity_codes), dtype=np.int64).ravel() + _, first = np.unique(codes_np, return_index=True) + first.sort() + return xp_asarray(first, dtype=xp.int64, xp=xp, ref_arr=ref_arr) + + +def _parameter_r2_components( + y, + X, + params, + *, + xp, + entity_codes=None, + has_constant: bool, +) -> Tuple[Optional[float], Optional[float], float, Dict[str, bool]]: + """Compute parameter-based within, between and overall R². + + ``has_constant`` refers to an actual identified constant in the level + regressor design. Fixed effects alone do not set this flag. The pooling-F + common-constant correction is a separate nested-test rule. + """ + params = params.ravel() + overall_resid = y - X @ params + overall_center = y - xp.mean(y) if has_constant else y + overall_ss_res = _to_float_scalar(xp.sum(overall_resid * overall_resid)) + overall_ss_tot = _to_float_scalar(xp.sum(overall_center * overall_center)) + overall, deg_o = _safe_r2(overall_ss_res, overall_ss_tot) + + if entity_codes is None: + return None, None, overall, { + "within": False, + "between": False, + "overall": deg_o, + } + + y_mean_aligned = group_means(y, entity_codes, xp=xp) + X_mean_aligned = X.clone() if getattr(xp, "__name__", "") == "torch" else X.copy() + for j in range(int(X.shape[1])): + X_mean_aligned[:, j] = group_means(X[:, j], entity_codes, xp=xp) + first = _first_group_indices(entity_codes, xp, X) + y_between = y_mean_aligned[first] + X_between = X_mean_aligned[first] + between_resid = y_between - X_between @ params + between_center = y_between - xp.mean(y_between) if has_constant else y_between + between_ss_res = _to_float_scalar(xp.sum(between_resid * between_resid)) + between_ss_tot = _to_float_scalar(xp.sum(between_center * between_center)) + between, deg_b = _safe_r2(between_ss_res, between_ss_tot) + + y_within = y - y_mean_aligned + X_within = _demean_matrix(X, entity_codes, xp) + within_resid = y_within - X_within @ params + within_ss_res = _to_float_scalar(xp.sum(within_resid * within_resid)) + within_ss_tot = _to_float_scalar(xp.sum(y_within * y_within)) + within, deg_w = _safe_r2(within_ss_res, within_ss_tot) + + return within, between, overall, { + "within": deg_w, + "between": deg_b, + "overall": deg_o, + } + + +def _adjusted_r2( + *, + rss: float, + tss: float, + df_resid: int, + df_total: int, +) -> Optional[float]: + if int(df_resid) <= 0 or int(df_total) <= 0: + return None + if float(tss) <= 0.0: + return 0.0 + return 1.0 - (float(rss) / float(df_resid)) / ( + float(tss) / float(df_total) + ) + + +def _classical_model_f( + y, + X, + params, + *, + xp, + df_resid: int, + has_constant: bool, +) -> Tuple[Optional[float], Optional[float], Optional[Tuple[float, float]], Dict[str, Any]]: + """Classical homoskedastic joint-slope F statistic in the fit space.""" + rank_u = _matrix_rank(X, xp) + rank_r = 1 if has_constant else 0 + q = rank_u - rank_r + metadata = { + "classical_homoskedastic": True, + "rank_unrestricted": rank_u, + "rank_restricted": rank_r, + "restriction_rank": q, + } + if q <= 0 or int(df_resid) <= 0: + metadata["unavailable_reason"] = "no estimable non-constant restrictions" + return None, None, None, metadata + + resid = y - X @ params.ravel() + rss_u = _to_float_scalar(xp.sum(resid * resid)) + if has_constant: + y_r = y - xp.mean(y) + rss_r = _to_float_scalar(xp.sum(y_r * y_r)) + else: + rss_r = _to_float_scalar(xp.sum(y * y)) + + diff = rss_r - rss_u + tol = 256.0 * np.finfo(np.float64).eps * max(1.0, abs(rss_r), abs(rss_u)) + if diff < -tol: + metadata["unavailable_reason"] = "restricted RSS is materially below unrestricted RSS" + metadata["rss_restricted"] = float(rss_r) + metadata["rss_unrestricted"] = float(rss_u) + return None, None, None, metadata + if diff < 0.0: + diff = 0.0 + metadata["roundoff_normalized"] = True + + if rss_u <= 0.0: + metadata["unavailable_reason"] = "unrestricted residual sum of squares is zero" + return None, None, None, metadata + + statistic = (diff / q) / (rss_u / int(df_resid)) + dist = get_distribution("f", backend="numpy") + pvalue = _to_float_scalar(dist.sf(statistic, q, int(df_resid))) + metadata["rss_restricted"] = float(rss_r) + metadata["rss_unrestricted"] = float(rss_u) + return float(statistic), float(pvalue), (float(q), float(df_resid)), metadata + + +def _build_fit_statistics( + y, + X, + params, + *, + xp, + entity_codes=None, + has_constant: bool, + rss_fit: float, + tss_fit: float, + df_resid: int, + df_total: int, + f_y=None, + f_X=None, + f_params=None, + f_has_constant: Optional[bool] = None, + metadata: Optional[Dict[str, Any]] = None, +) -> PanelFitStatistics: + within, between, overall, degenerate = _parameter_r2_components( + y, + X, + params, + xp=xp, + entity_codes=entity_codes, + has_constant=bool(has_constant), + ) + f_stat, f_pvalue, f_df, f_meta = _classical_model_f( + y if f_y is None else f_y, + X if f_X is None else f_X, + params if f_params is None else f_params, + xp=xp, + df_resid=int(df_resid), + has_constant=( + bool(has_constant) if f_has_constant is None else bool(f_has_constant) + ), + ) + meta = {} if metadata is None else dict(metadata) + meta.setdefault("r2_definition", "parameter-based") + meta["degenerate_total_ss"] = degenerate + meta["rsquared_adj_basis"] = { + "df_total": int(df_total), + "df_resid": int(df_resid), + } + meta["model_f"] = f_meta + if entity_codes is None: + meta.setdefault("unavailable", {})["within_between_r2"] = ( + "entity_ids were not supplied" + ) + return PanelFitStatistics( + rsquared_within=within, + rsquared_between=between, + rsquared_overall=overall, + rsquared_adj=_adjusted_r2( + rss=float(rss_fit), + tss=float(tss_fit), + df_resid=int(df_resid), + df_total=int(df_total), + ), + f_statistic=f_stat, + f_pvalue=f_pvalue, + f_df=f_df, + metadata=meta, + ) + + +def _pooling_f_from_sums( + *, + rss_pooled: float, + rss_effects: float, + df_num: int, + df_denom: int, + metadata: Optional[Dict[str, Any]] = None, +) -> PanelTestResult: + null = "all included fixed effects are jointly zero" + alternative = "at least one included fixed effect is nonzero" + meta = {} if metadata is None else dict(metadata) + meta.update( + { + "rss_pooled": float(rss_pooled), + "rss_effects": float(rss_effects), + "classical_homoskedastic": True, + } + ) + if int(df_num) <= 0 or int(df_denom) <= 0: + return _inapplicable( + null=null, + alternative=alternative, + distribution="F", + df=(float(df_num), float(df_denom)), + reason="pooling F requires positive numerator and denominator degrees of freedom", + metadata=meta, + ) + if float(rss_effects) <= 0.0: + return _inapplicable( + null=null, + alternative=alternative, + distribution="F", + df=(float(df_num), float(df_denom)), + reason="fixed-effects residual sum of squares must be positive", + metadata=meta, + ) + + diff = float(rss_pooled) - float(rss_effects) + tol = 256.0 * np.finfo(np.float64).eps * max( + 1.0, abs(float(rss_pooled)), abs(float(rss_effects)) + ) + if diff < -tol: + return _inapplicable( + null=null, + alternative=alternative, + distribution="F", + df=(float(df_num), float(df_denom)), + reason="pooled RSS is materially below fixed-effects RSS; nested-model contract failed", + metadata=meta, + ) + if diff < 0.0: + diff = 0.0 + meta["roundoff_normalized"] = True + + statistic = (diff / int(df_num)) / (float(rss_effects) / int(df_denom)) + dist = get_distribution("f", backend="numpy") + pvalue = _to_float_scalar(dist.sf(statistic, int(df_num), int(df_denom))) + return _applicable( + statistic, + pvalue, + null=null, + alternative=alternative, + distribution="F", + df=(float(df_num), float(df_denom)), + metadata=meta, + ) + + +def _bp_lm_from_components( + *, + nobs: int, + residual_ss: float, + group_residual_sums: Sequence[float], + group_counts: Sequence[float], +) -> PanelTestResult: + null = "the entity random-effect variance is zero" + alternative = "a nonzero entity random-effect variance component is present" + sums = np.asarray(group_residual_sums, dtype=np.float64).ravel() + counts = np.asarray(group_counts, dtype=np.float64).ravel() + meta = { + "n_entities": int(counts.size), + "nobs": int(nobs), + "residual_ss": float(residual_ss), + "definition": "Baltagi-Li one-way unbalanced Breusch-Pagan LM", + } + if sums.size != counts.size or counts.size < 2: + return _inapplicable( + null=null, + alternative=alternative, + distribution="chi2", + df=1.0, + reason="Breusch-Pagan LM requires at least two entities", + metadata=meta, + ) + if float(residual_ss) <= 0.0: + return _inapplicable( + null=null, + alternative=alternative, + distribution="chi2", + df=1.0, + reason="pooled residual sum of squares must be positive", + metadata=meta, + ) + m11 = float(np.sum(counts * counts)) + if m11 <= int(nobs): + meta["M11"] = m11 + return _inapplicable( + null=null, + alternative=alternative, + distribution="chi2", + df=1.0, + reason="Breusch-Pagan LM requires at least one entity with repeated observations", + metadata=meta, + ) + + a1 = float(np.sum(sums * sums) / float(residual_ss) - 1.0) + lm1 = int(nobs) * np.sqrt(1.0 / (2.0 * (m11 - int(nobs)))) * a1 + statistic = float(lm1 * lm1) + dist = get_distribution("chi2", backend="numpy") + pvalue = _to_float_scalar(dist.sf(statistic, 1.0)) + meta.update({"A1": a1, "M11": m11, "LM1": float(lm1)}) + return _applicable( + statistic, + pvalue, + null=null, + alternative=alternative, + distribution="chi2", + df=1.0, + metadata=meta, + ) + + +def _hausman_quadratic( + difference: Sequence[float], + covariance_difference, +) -> PanelTestResult: + null = "the random-effects estimator is consistent" + alternative = "the random-effects estimator is inconsistent" + d = np.asarray(difference, dtype=np.float64).ravel() + D = np.asarray(covariance_difference, dtype=np.float64) + if D.shape != (d.size, d.size): + raise ValueError("covariance difference shape must match coefficient difference") + if d.size == 0: + return _inapplicable( + null=null, + alternative=alternative, + distribution="chi2", + df=0.0, + reason="Hausman test has no common estimable slope coefficients", + ) + + D = 0.5 * (D + D.T) + eigvals, eigvecs = np.linalg.eigh(D) + norm_D = float(np.linalg.norm(D, ord=2)) if D.size else 0.0 + tol = 256.0 * np.finfo(np.float64).eps * max(1.0, norm_D) * max(1, d.size) + meta = { + "eigen_tolerance": tol, + "minimum_eigenvalue": float(eigvals.min()), + "maximum_eigenvalue": float(eigvals.max()), + } + if float(eigvals.min()) < -tol: + return _inapplicable( + null=null, + alternative=alternative, + distribution="chi2", + reason="covariance difference is not positive semidefinite", + metadata=meta, + ) + + positive = eigvals > tol + rank = int(np.count_nonzero(positive)) + meta["rank"] = rank + if rank == 0: + return _inapplicable( + null=null, + alternative=alternative, + distribution="chi2", + df=0.0, + reason="covariance difference has zero numerical rank", + metadata=meta, + ) + + basis = eigvecs[:, positive] + projected = basis @ (basis.T @ d) + null_component = d - projected + range_tol = 1024.0 * np.finfo(np.float64).eps * max(1.0, np.linalg.norm(d)) + meta["range_tolerance"] = float(range_tol) + meta["nullspace_component_norm"] = float(np.linalg.norm(null_component)) + if float(np.linalg.norm(null_component)) > range_tol: + return _inapplicable( + null=null, + alternative=alternative, + distribution="chi2", + df=float(rank), + reason="coefficient difference has a component outside the identified covariance-difference range", + metadata=meta, + ) + + inv_eigs = 1.0 / eigvals[positive] + statistic = float((basis.T @ d).T @ (inv_eigs * (basis.T @ d))) + stat_tol = 256.0 * np.finfo(np.float64).eps * max(1.0, abs(statistic)) + if statistic < -stat_tol: + return _inapplicable( + null=null, + alternative=alternative, + distribution="chi2", + df=float(rank), + reason="Hausman quadratic form is materially negative", + metadata=meta, + ) + if statistic < 0.0: + statistic = 0.0 + meta["roundoff_normalized"] = True + + if rank < d.size: + meta["used_pinv"] = True + meta["definition_extension"] = "singular PSD generalized-inverse Hausman" + else: + meta["used_pinv"] = False + + dist = get_distribution("chi2", backend="numpy") + pvalue = _to_float_scalar(dist.sf(statistic, float(rank))) + return _applicable( + statistic, + pvalue, + null=null, + alternative=alternative, + distribution="chi2", + df=float(rank), + metadata=meta, + ) + + +def _row_weights(n: int, xp, ref_arr): + if getattr(xp, "__name__", "") == "torch": + return xp.arange( + 1, + int(n) + 1, + dtype=xp.float64, + device=ref_arr.device, + ) + return xp.arange(1, int(n) + 1, dtype=xp.float64) + + +def _numerical_fingerprint(X, y, *, xp) -> Dict[str, np.ndarray]: + """Reduce aligned X/y/order to O(k) deterministic float64 moments.""" + n = int(X.shape[0]) + weights = _row_weights(n, xp, X) + X_sum = xp.sum(X, axis=0) + X_sq = xp.sum(X * X, axis=0) + X_weighted = xp.sum(X * weights.reshape(-1, 1), axis=0) + y_sum = xp.sum(y) + y_sq = xp.sum(y * y) + y_weighted = xp.sum(y * weights) + return { + "X_sum": np.asarray(_to_numpy(X_sum), dtype=np.float64).ravel(), + "X_sq": np.asarray(_to_numpy(X_sq), dtype=np.float64).ravel(), + "X_weighted": np.asarray(_to_numpy(X_weighted), dtype=np.float64).ravel(), + "y": np.asarray( + [ + _to_float_scalar(y_sum), + _to_float_scalar(y_sq), + _to_float_scalar(y_weighted), + ], + dtype=np.float64, + ), + } + + +def _metadata_signature(codes) -> Optional[str]: + if codes is None: + return None + arr = np.asarray(_to_numpy(codes), dtype=np.int64).ravel() + return hashlib.sha256(arr.tobytes()).hexdigest() + + +def _diagnostic_identity( + X, + y, + *, + xp, + entity_codes=None, + feature_names: Optional[Sequence[str]] = None, + has_constant: bool = False, +) -> Dict[str, Any]: + k = int(X.shape[1]) + names = tuple(feature_names) if feature_names is not None else tuple( + f"x{i + 1}" for i in range(k) + ) + return { + "nobs": int(X.shape[0]), + "n_features": k, + "feature_names": names, + "has_constant": bool(has_constant), + "entity_signature": _metadata_signature(entity_codes), + "fingerprint": _numerical_fingerprint(X, y, xp=xp), + } + + +def _fingerprints_match(left: Dict[str, Any], right: Dict[str, Any]) -> Tuple[bool, str]: + scalar_keys = ("nobs", "n_features", "feature_names", "has_constant", "entity_signature") + for key in scalar_keys: + if left.get(key) != right.get(key): + return False, f"diagnostic identity mismatch: {key}" + lf = left.get("fingerprint") + rf = right.get("fingerprint") + if not isinstance(lf, dict) or not isinstance(rf, dict): + return False, "diagnostic identity is missing numerical fingerprint metadata" + for key in ("X_sum", "X_sq", "X_weighted", "y"): + if key not in lf or key not in rf: + return False, f"diagnostic fingerprint is missing {key}" + if not np.allclose( + np.asarray(lf[key]), + np.asarray(rf[key]), + rtol=5e-11, + atol=5e-12, + ): + return False, f"diagnostic numerical fingerprint mismatch: {key}" + return True, "" + + +def pooling_f_test(fe_model) -> PanelTestResult: + """Return the classical fixed-effect poolability F test.""" + from statgpu.panel._fixed_effects import PanelOLS + + if not isinstance(fe_model, PanelOLS): + raise TypeError("pooling_f_test requires a fitted PanelOLS model") + fe_model._check_is_fitted() + if not (bool(fe_model.entity_effects) or bool(fe_model.time_effects)): + return _inapplicable( + null="all included fixed effects are jointly zero", + alternative="at least one included fixed effect is nonzero", + distribution="F", + reason="pooling F requires at least one fixed-effect dimension", + ) + result = getattr(fe_model, "_pooling_f_result", None) + if result is None: + return _inapplicable( + null="all included fixed effects are jointly zero", + alternative="at least one included fixed effect is nonzero", + distribution="F", + reason="pooling F sufficient statistics were not retained by this fitted model", + ) + return result + + +def breusch_pagan_lm_test(pooled_model) -> PanelTestResult: + """Return the one-way entity error-components Breusch-Pagan LM test.""" + from statgpu.panel._pooled import PooledOLS + + if not isinstance(pooled_model, PooledOLS): + raise TypeError("breusch_pagan_lm_test requires a fitted PooledOLS model") + pooled_model._check_is_fitted() + result = getattr(pooled_model, "_bp_lm_result", None) + if result is None: + return _inapplicable( + null="the entity random-effect variance is zero", + alternative="a nonzero entity random-effect variance component is present", + distribution="chi2", + df=1.0, + reason="entity_ids were not supplied to the pooled fit", + ) + return result + + +def hausman_test(fe_model, re_model) -> PanelTestResult: + """Return the classical one-way FE-vs-RE Hausman specification test.""" + from statgpu.panel._fixed_effects import PanelOLS + from statgpu.panel._random_effects import RandomEffects + + if not isinstance(fe_model, PanelOLS): + raise TypeError("hausman_test fe_model must be a fitted PanelOLS") + if not isinstance(re_model, RandomEffects): + raise TypeError("hausman_test re_model must be a fitted RandomEffects") + fe_model._check_is_fitted() + re_model._check_is_fitted() + + null = "the random-effects estimator is consistent" + alternative = "the random-effects estimator is inconsistent" + if not bool(fe_model.entity_effects) or bool(fe_model.time_effects): + return _inapplicable( + null=null, + alternative=alternative, + distribution="chi2", + reason="classical Stage-B Hausman requires one-way entity PanelOLS", + ) + if str(getattr(fe_model, "_cov_type", "nonrobust")).lower() != "nonrobust": + return _inapplicable( + null=null, + alternative=alternative, + distribution="chi2", + reason="classical Hausman requires nonrobust FE covariance; robust auxiliary Hausman is not implemented in Stage B", + ) + + left_id = getattr(fe_model, "_panel_diagnostic_identity", None) + right_id = getattr(re_model, "_panel_diagnostic_identity", None) + if not isinstance(left_id, dict) or not isinstance(right_id, dict): + return _inapplicable( + null=null, + alternative=alternative, + distribution="chi2", + reason="fitted models do not contain Stage-B sample/design identity metadata", + ) + matched, reason = _fingerprints_match(left_id, right_id) + if not matched: + return _inapplicable( + null=null, + alternative=alternative, + distribution="chi2", + reason=reason, + ) + + fe_cov = getattr(fe_model, "_panel_cov_params", None) + re_cov = getattr(re_model, "_panel_cov_params", None) + if fe_cov is None or re_cov is None: + return _inapplicable( + null=null, + alternative=alternative, + distribution="chi2", + reason="fitted models do not contain the small covariance matrices required for Hausman", + ) + + fe_names = tuple(left_id.get("feature_names", ())) + re_names = tuple(right_id.get("feature_names", ())) + common = [name for name in fe_names if name in set(re_names)] + if not common: + return _inapplicable( + null=null, + alternative=alternative, + distribution="chi2", + reason="Hausman test has no common estimable slope coefficients", + ) + fe_lookup = {name: i for i, name in enumerate(fe_names)} + re_lookup = {name: i for i, name in enumerate(re_names)} + fe_idx = np.asarray([fe_lookup[name] for name in common], dtype=np.int64) + re_idx = np.asarray([re_lookup[name] for name in common], dtype=np.int64) + fe_coef = np.asarray(fe_model.coef_, dtype=np.float64).ravel()[fe_idx] + re_coef = np.asarray(re_model.coef_, dtype=np.float64).ravel()[re_idx] + fe_cov = np.asarray(fe_cov, dtype=np.float64)[np.ix_(fe_idx, fe_idx)] + re_cov = np.asarray(re_cov, dtype=np.float64)[np.ix_(re_idx, re_idx)] + result = _hausman_quadratic(fe_coef - re_coef, fe_cov - re_cov) + meta = dict(result.metadata) + meta["common_features"] = tuple(common) + return PanelTestResult( + statistic=result.statistic, + pvalue=result.pvalue, + distribution=result.distribution, + df=result.df, + null=result.null, + alternative=result.alternative, + applicable=result.applicable, + reason=result.reason, + metadata=meta, + ) From d69325addd9c848145c536e02b9c72c354facc25 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 10:44:55 +0800 Subject: [PATCH 004/165] test: add analytic Panel Stage B diagnostic contracts --- dev/tests/test_panel_stage_b_diagnostics.py | 244 ++++++++++++++++++++ 1 file changed, 244 insertions(+) create mode 100644 dev/tests/test_panel_stage_b_diagnostics.py diff --git a/dev/tests/test_panel_stage_b_diagnostics.py b/dev/tests/test_panel_stage_b_diagnostics.py new file mode 100644 index 000000000..e2d9a89d7 --- /dev/null +++ b/dev/tests/test_panel_stage_b_diagnostics.py @@ -0,0 +1,244 @@ +"""Analytic contracts for Panel Tier-1 Stage B diagnostics.""" + +from __future__ import annotations + +import numpy as np +from numpy.testing import assert_allclose +from scipy import stats + +from statgpu.panel._diagnostics import ( + _bp_lm_from_components, + _build_fit_statistics, + _diagnostic_identity, + _fingerprints_match, + _hausman_quadratic, + _pooling_f_from_sums, +) +from statgpu.panel._results import PanelFitStatistics, PanelTestResult + + +def test_pooling_f_matches_hand_formula(): + result = _pooling_f_from_sums( + rss_pooled=18.0, + rss_effects=12.0, + df_num=3, + df_denom=40, + metadata={"constant_correction": False}, + ) + expected = ((18.0 - 12.0) / 3.0) / (12.0 / 40.0) + assert isinstance(result, PanelTestResult) + assert result.applicable + assert_allclose(result.statistic, expected, rtol=0, atol=1e-14) + assert_allclose(result.pvalue, stats.f.sf(expected, 3, 40), rtol=1e-12) + assert result.df == (3.0, 40.0) + assert result.metadata["classical_homoskedastic"] is True + + +def test_pooling_f_roundoff_negative_is_normalized_but_material_violation_is_not(): + tiny = _pooling_f_from_sums( + rss_pooled=10.0 - 1e-14, + rss_effects=10.0, + df_num=2, + df_denom=20, + ) + assert tiny.applicable + assert tiny.statistic == 0.0 + assert tiny.metadata["roundoff_normalized"] is True + + bad = _pooling_f_from_sums( + rss_pooled=9.0, + rss_effects=10.0, + df_num=2, + df_denom=20, + ) + assert not bad.applicable + assert "nested-model contract failed" in bad.reason + + +def test_bp_lm_matches_baltagi_li_unbalanced_formula(): + counts = np.asarray([2.0, 3.0, 4.0]) + group_sums = np.asarray([0.6, -0.2, 0.9]) + cp = 5.5 + nobs = int(counts.sum()) + a1 = np.sum(group_sums ** 2) / cp - 1.0 + m11 = np.sum(counts ** 2) + lm1 = nobs * np.sqrt(1.0 / (2.0 * (m11 - nobs))) * a1 + expected = lm1 ** 2 + + result = _bp_lm_from_components( + nobs=nobs, + residual_ss=cp, + group_residual_sums=group_sums, + group_counts=counts, + ) + assert result.applicable + assert result.df == 1.0 + assert_allclose(result.statistic, expected, rtol=0, atol=1e-14) + assert_allclose(result.pvalue, stats.chi2.sf(expected, 1), rtol=1e-12) + assert result.metadata["definition"].startswith("Baltagi-Li") + + +def test_bp_lm_rejects_singletons_only_and_zero_rss(): + singletons = _bp_lm_from_components( + nobs=3, + residual_ss=2.0, + group_residual_sums=[0.1, -0.1, 0.0], + group_counts=[1.0, 1.0, 1.0], + ) + assert not singletons.applicable + assert "repeated observations" in singletons.reason + + zero = _bp_lm_from_components( + nobs=4, + residual_ss=0.0, + group_residual_sums=[0.0, 0.0], + group_counts=[2.0, 2.0], + ) + assert not zero.applicable + assert "must be positive" in zero.reason + + +def test_hausman_full_rank_matches_quadratic_form(): + d = np.asarray([0.2, -0.1]) + D = np.asarray([[0.08, 0.01], [0.01, 0.05]]) + expected = float(d @ np.linalg.solve(D, d)) + result = _hausman_quadratic(d, D) + assert result.applicable + assert result.df == 2.0 + assert result.metadata["used_pinv"] is False + assert_allclose(result.statistic, expected, rtol=1e-12) + assert_allclose(result.pvalue, stats.chi2.sf(expected, 2), rtol=1e-12) + + +def test_hausman_singular_psd_uses_identified_range_and_rank_df(): + D = np.asarray([[2.0, 0.0], [0.0, 0.0]]) + result = _hausman_quadratic([1.0, 0.0], D) + assert result.applicable + assert result.df == 1.0 + assert result.metadata["used_pinv"] is True + assert result.metadata["definition_extension"].startswith("singular PSD") + assert_allclose(result.statistic, 0.5, rtol=0, atol=1e-14) + + outside = _hausman_quadratic([1.0, 0.1], D) + assert not outside.applicable + assert "outside the identified" in outside.reason + + +def test_hausman_indefinite_covariance_difference_is_explicitly_inapplicable(): + result = _hausman_quadratic([0.1, 0.2], [[1.0, 0.0], [0.0, -0.1]]) + assert not result.applicable + assert "not positive semidefinite" in result.reason + + +def test_parameter_based_r2_and_adjusted_r2_are_hand_checkable(): + entity = np.repeat(np.arange(3), 3) + X = np.column_stack( + [ + np.ones(9), + np.linspace(-1.0, 1.0, 9), + ] + ) + beta = np.asarray([1.2, 0.7]) + entity_shift = np.repeat(np.asarray([-0.4, 0.0, 0.5]), 3) + noise = np.asarray([0.1, -0.1, 0.0] * 3) + y = X @ beta + entity_shift + noise + resid = y - X @ beta + rss = float(resid @ resid) + tss = float(np.sum((y - y.mean()) ** 2)) + + result = _build_fit_statistics( + y, + X, + beta, + xp=np, + entity_codes=entity, + has_constant=True, + rss_fit=rss, + tss_fit=tss, + df_resid=7, + df_total=8, + metadata={"fit_space": "pooled"}, + ) + assert isinstance(result, PanelFitStatistics) + expected_overall = 1.0 - rss / tss + expected_adj = 1.0 - (rss / 7.0) / (tss / 8.0) + assert_allclose(result.rsquared_overall, expected_overall, rtol=1e-12) + assert_allclose(result.rsquared_adj, expected_adj, rtol=1e-12) + assert result.rsquared_within is not None + assert result.rsquared_between is not None + assert result.f_statistic is not None + assert result.f_df == (1.0, 7.0) + + +def test_standardized_r2_zero_tss_is_zero_with_metadata(): + X = np.ones((6, 1)) + y = np.ones(6) + result = _build_fit_statistics( + y, + X, + np.asarray([1.0]), + xp=np, + entity_codes=np.repeat(np.arange(3), 2), + has_constant=True, + rss_fit=0.0, + tss_fit=0.0, + df_resid=5, + df_total=5, + ) + assert result.rsquared_overall == 0.0 + assert result.rsquared_between == 0.0 + assert result.rsquared_within == 0.0 + assert result.rsquared_adj == 0.0 + assert result.metadata["degenerate_total_ss"] == { + "within": True, + "between": True, + "overall": True, + } + + +def test_numerical_fingerprint_detects_row_order_and_data_changes(): + X = np.arange(12.0).reshape(6, 2) / 10.0 + y = np.linspace(-0.5, 0.5, 6) + entity = np.asarray([0, 0, 1, 1, 2, 2]) + left = _diagnostic_identity( + X, + y, + xp=np, + entity_codes=entity, + feature_names=["x1", "x2"], + ) + same = _diagnostic_identity( + X.copy(), + y.copy(), + xp=np, + entity_codes=entity.copy(), + feature_names=["x1", "x2"], + ) + ok, reason = _fingerprints_match(left, same) + assert ok + assert reason == "" + + changed_y = y.copy() + changed_y[-1] += 0.2 + different = _diagnostic_identity( + X, + changed_y, + xp=np, + entity_codes=entity, + feature_names=["x1", "x2"], + ) + ok, reason = _fingerprints_match(left, different) + assert not ok + assert "fingerprint mismatch" in reason + + order = np.asarray([1, 0, 2, 3, 4, 5]) + reordered = _diagnostic_identity( + X[order], + y[order], + xp=np, + entity_codes=entity[order], + feature_names=["x1", "x2"], + ) + ok, reason = _fingerprints_match(left, reordered) + assert not ok + assert "identity mismatch" in reason or "fingerprint mismatch" in reason From 189ed684a10ba9f689fa4d648e6e881d27e39e06 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 10:46:51 +0800 Subject: [PATCH 005/165] plan: separate legacy FE df from Stage B diagnostic df --- ...anel_p1_stage_b_diagnostics_df_addendum.md | 87 +++++++++++++++++++ 1 file changed, 87 insertions(+) create mode 100644 dev/plans/panel_p1_stage_b_diagnostics_df_addendum.md diff --git a/dev/plans/panel_p1_stage_b_diagnostics_df_addendum.md b/dev/plans/panel_p1_stage_b_diagnostics_df_addendum.md new file mode 100644 index 000000000..b376b0269 --- /dev/null +++ b/dev/plans/panel_p1_stage_b_diagnostics_df_addendum.md @@ -0,0 +1,87 @@ +# Panel Stage B diagnostic-df addendum + +This addendum is normative for `panel_p1_stage_b_diagnostics_plan.md` and closes a second-round definition issue discovered immediately before estimator integration. + +## Why a separate diagnostic df is required + +Stage A intentionally preserved the historical `PanelOLS.df_resid` convention: + +```text +df_resid_legacy = n - k - [(N - 1) entity effects] - [(T - 1) time effects] +``` + +for the corresponding included effects. This quantity continues to drive the existing nonrobust/robust covariance, t statistics, p-values, and confidence intervals and **must not change in Stage B**. + +The standard poolability/model-F definitions in `linearmodels`/`plm`, however, count the rank of the full fixed-effect nuisance space. With no explicit exogenous constant, a one-way entity FE model has nuisance-effect rank `N`; a two-way entity+time model has effect rank `N + T - 1`. In the ordinary full-rank case this makes the standard diagnostic residual df one lower than statgpu's legacy Stage-A inference df. + +Therefore Stage B introduces an internal **standard diagnostic residual df** rather than changing `model.df_resid`. + +## Standard diagnostic rank/df + +Let `r_x` be the numerical rank of the transformed slope design used for FE estimation. + +For current statgpu `PanelOLS`, formula intercepts are stripped before fitting and the estimator does not add a separate constant. Consequently the standard effect-space rank is: + +- no effects: `0`; +- entity only: `N`; +- time only: `T`; +- entity + time: `N + T - 1`. + +Then + +```text +df_model_diag = r_x + effect_rank_standard +df_resid_diag = n - df_model_diag +``` + +The implementation stores these values only in Stage-B diagnostic metadata/internal context. It does not overwrite the Stage-A `df_resid` attribute. + +If a future PanelOLS path contains a retained identified exogenous constant, the effect-rank accounting must switch to the equivalent constant-present parameterization rather than double counting the common mean. + +## Which Stage-B quantities use which df + +Use **standard diagnostic df** for new standardized diagnostics whose external definitions depend on model rank: + +- pooling F denominator df; +- pooling F numerator df through nested-model rank difference; +- `PanelFitStatistics.f_statistic` denominator df for `PanelOLS`; +- `PanelFitStatistics.rsquared_adj` residual df for `PanelOLS`. + +Use the existing **legacy Stage-A df** unchanged for: + +- existing covariance calculations; +- existing `bse_`, `tvalues_`, `pvalues_`, `conf_int_`; +- existing public `PanelOLS.df_resid`; +- any legacy summary field that already reports it. + +For PooledOLS, BetweenOLS, FirstDifferenceOLS, and RandomEffects, Stage B should use effective numerical rank for the new model-F/adjusted-R² metadata. When the existing fit is full rank this agrees with the current residual df. Stage B does not modify legacy inference df if a rank-deficient corner case exposes a difference. + +## Pooling F after this correction + +Construct the pooled null on the exact aligned level sample. Since current statgpu FE does not retain an exogenous constant, apply the same common-constant projection used by `linearmodels` before the pooled slope regression. Let + +```text +df_pool_diag = n - rank(X_centered) - 1 +``` + +where the `-1` is the projected common constant. Then + +```text +df_num = df_pool_diag - df_resid_diag_FE +F = ((RSS_pool - RSS_FE) / df_num) / (RSS_FE / df_resid_diag_FE) +``` + +This is equivalent to the external effect-rank formulation in the ordinary full-rank case and remains auditable under rank deficiency. + +Roundoff/material nesting-failure behavior from the main plan remains unchanged. + +## R² constant convention clarification + +For standardized parameter-based **overall** and **between** R², centering depends on an actual identified constant in the level exogenous design. Fixed effects alone do not set `has_constant=True` for these two parameter-based measures. + +The common-constant projection used by the **pooling F test** is a separate nested-test construction and must not be reused as a general R² centering rule. + +## Review status + +- **[HIGH][INFER] fixed in specification** — Stage-B poolability/model-F inference will no longer reuse a legacy FE residual df that differs from the standard nuisance-effect rank convention. +- **[MEDIUM][INFER] fixed in specification** — overall/between R² centering is explicitly separated from the pooling-F common-constant correction. From 8e949125242f9e1972dee2e75a455844948f494e Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 10:48:06 +0800 Subject: [PATCH 006/165] plan: define FE adjusted R-squared total df --- ...anel_p1_stage_b_diagnostics_df_addendum.md | 19 +++++++++++++++++-- 1 file changed, 17 insertions(+), 2 deletions(-) diff --git a/dev/plans/panel_p1_stage_b_diagnostics_df_addendum.md b/dev/plans/panel_p1_stage_b_diagnostics_df_addendum.md index b376b0269..0c73a8423 100644 --- a/dev/plans/panel_p1_stage_b_diagnostics_df_addendum.md +++ b/dev/plans/panel_p1_stage_b_diagnostics_df_addendum.md @@ -1,6 +1,6 @@ # Panel Stage B diagnostic-df addendum -This addendum is normative for `panel_p1_stage_b_diagnostics_plan.md` and closes a second-round definition issue discovered immediately before estimator integration. +This addendum is normative for `panel_p1_stage_b_diagnostics_plan.md` and closes second-round definition issues discovered immediately before estimator integration. ## Why a separate diagnostic df is required @@ -36,6 +36,20 @@ df_resid_diag = n - df_model_diag The implementation stores these values only in Stage-B diagnostic metadata/internal context. It does not overwrite the Stage-A `df_resid` attribute. +The primary transformed FE response lives in the orthogonal complement of the nuisance-effect space, so the corresponding total-variation degrees of freedom for Stage-B adjusted R² are + +```text +df_total_diag = n - effect_rank_standard +``` + +and hence + +```text +R2_adj = 1 - (RSS / df_resid_diag) / (TSS_transformed / df_total_diag). +``` + +This replaces the earlier provisional `n-1` wording in the main plan for FE adjusted R². It is the rank-consistent definition: the restricted zero-slope model has exactly the nuisance effects removed before the transformed total sum of squares is formed. + If a future PanelOLS path contains a retained identified exogenous constant, the effect-rank accounting must switch to the equivalent constant-present parameterization rather than double counting the common mean. ## Which Stage-B quantities use which df @@ -45,7 +59,7 @@ Use **standard diagnostic df** for new standardized diagnostics whose external d - pooling F denominator df; - pooling F numerator df through nested-model rank difference; - `PanelFitStatistics.f_statistic` denominator df for `PanelOLS`; -- `PanelFitStatistics.rsquared_adj` residual df for `PanelOLS`. +- `PanelFitStatistics.rsquared_adj` residual and total df for `PanelOLS`. Use the existing **legacy Stage-A df** unchanged for: @@ -84,4 +98,5 @@ The common-constant projection used by the **pooling F test** is a separate nest ## Review status - **[HIGH][INFER] fixed in specification** — Stage-B poolability/model-F inference will no longer reuse a legacy FE residual df that differs from the standard nuisance-effect rank convention. +- **[MEDIUM][INFER] fixed in specification** — FE adjusted R² now uses nuisance-rank-consistent total df rather than provisional `n-1`. - **[MEDIUM][INFER] fixed in specification** — overall/between R² centering is explicitly separated from the pooling-F common-constant correction. From 95250318407d9c76c889fa3d43def176d87cd58c Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 10:48:51 +0800 Subject: [PATCH 007/165] feat: add Panel Stage B estimator diagnostic context helpers --- statgpu/panel/_diagnostic_context.py | 221 +++++++++++++++++++++++++++ 1 file changed, 221 insertions(+) create mode 100644 statgpu/panel/_diagnostic_context.py diff --git a/statgpu/panel/_diagnostic_context.py b/statgpu/panel/_diagnostic_context.py new file mode 100644 index 000000000..a4c0a9137 --- /dev/null +++ b/statgpu/panel/_diagnostic_context.py @@ -0,0 +1,221 @@ +"""Estimator-integration helpers for Panel Tier-1 Stage B diagnostics. + +This module keeps observation-scale sufficient-statistic work backend-native and +bridges fitted estimator arrays to the structured primitives in +``statgpu.panel._diagnostics``. +""" + +from __future__ import annotations + +import numpy as np + +from statgpu.backends import _to_float_scalar +from statgpu.inference._distributions_backend import get_distribution +from statgpu.panel._diagnostics import ( + _applicable, + _build_fit_statistics, + _diagnostic_identity, + _inapplicable, + _matrix_rank, + _pooling_f_from_sums, +) +from statgpu.panel._utils import group_means, group_sizes + + +def effect_rank_standard( + *, + n_entities: int, + n_times: int, + entity_effects: bool, + time_effects: bool, + has_constant: bool = False, +) -> int: + """Return the nuisance-effect rank under the standard FE parameterization.""" + n_entities = int(n_entities) + n_times = int(n_times) + if not entity_effects and not time_effects: + return 0 + + if has_constant: + rank = 0 + if entity_effects: + rank += max(n_entities - 1, 0) + if time_effects: + rank += max(n_times - 1, 0) + return int(rank) + + if entity_effects and time_effects: + return int(max(n_entities + n_times - 1, 0)) + if entity_effects: + return int(max(n_entities, 0)) + return int(max(n_times, 0)) + + +def fixed_effect_diagnostic_df( + X_transformed, + *, + xp, + nobs: int, + n_entities: int, + n_times: int, + entity_effects: bool, + time_effects: bool, + has_constant: bool = False, +): + """Return rank-consistent Stage-B FE diagnostic df without changing legacy df.""" + rank_x = _matrix_rank(X_transformed, xp) + effect_rank = effect_rank_standard( + n_entities=n_entities, + n_times=n_times, + entity_effects=entity_effects, + time_effects=time_effects, + has_constant=has_constant, + ) + df_resid = int(nobs) - int(rank_x) - int(effect_rank) + df_total = int(nobs) - int(effect_rank) + return { + "rank_x": int(rank_x), + "effect_rank": int(effect_rank), + "df_resid": int(df_resid), + "df_total": int(df_total), + "legacy_df_unchanged": True, + } + + +def pooling_f_from_level_arrays( + y, + X, + *, + xp, + rss_effects: float, + df_resid_effects: int, + has_constant: bool = False, +): + """Construct the nested pooled null on the exact aligned FE level sample.""" + n = int(y.shape[0]) + if has_constant: + y_pool = y + X_pool = X + constant_projection_df = 0 + else: + y_pool = y - xp.mean(y) + X_pool = X - xp.mean(X, axis=0) + constant_projection_df = 1 + + rank_pool = _matrix_rank(X_pool, xp) + beta_pool = xp.linalg.pinv(X_pool) @ y_pool + resid_pool = y_pool - X_pool @ beta_pool + rss_pool = _to_float_scalar(xp.sum(resid_pool * resid_pool)) + df_resid_pool = n - rank_pool - constant_projection_df + df_num = int(df_resid_pool) - int(df_resid_effects) + return _pooling_f_from_sums( + rss_pooled=float(rss_pool), + rss_effects=float(rss_effects), + df_num=int(df_num), + df_denom=int(df_resid_effects), + metadata={ + "rank_pooled": int(rank_pool), + "df_resid_pooled": int(df_resid_pool), + "df_resid_effects_standard": int(df_resid_effects), + "constant_projection_df": int(constant_projection_df), + "has_explicit_level_constant": bool(has_constant), + }, + ) + + +def bp_lm_from_residuals(resid, entity_codes, *, xp): + """Compute the one-way Baltagi-Li BP-LM from pooled residuals on backend.""" + null = "the entity random-effect variance is zero" + alternative = "a nonzero entity random-effect variance component is present" + if entity_codes is None: + return _inapplicable( + null=null, + alternative=alternative, + distribution="chi2", + df=1.0, + reason="entity_ids were not supplied to the pooled fit", + ) + + nobs = int(resid.shape[0]) + codes_np = np.asarray(entity_codes if xp is np else entity_codes.get() if getattr(xp, "__name__", "") == "cupy" else entity_codes.detach().cpu().numpy()).ravel() + n_entities = int(np.unique(codes_np).size) + meta = { + "n_entities": n_entities, + "nobs": nobs, + "definition": "Baltagi-Li one-way unbalanced Breusch-Pagan LM", + } + if n_entities < 2: + return _inapplicable( + null=null, + alternative=alternative, + distribution="chi2", + df=1.0, + reason="Breusch-Pagan LM requires at least two entities", + metadata=meta, + ) + + residual_ss = _to_float_scalar(xp.sum(resid * resid)) + if residual_ss <= 0.0: + meta["residual_ss"] = float(residual_ss) + return _inapplicable( + null=null, + alternative=alternative, + distribution="chi2", + df=1.0, + reason="pooled residual sum of squares must be positive", + metadata=meta, + ) + + mean_aligned = group_means(resid, entity_codes, xp=xp) + sizes_aligned = group_sizes(entity_codes, xp=xp) + # Repeated aligned values allow scalar reductions without transferring the + # entity-level residual-sum vector to CPU. sum_i s_i^2 equals + # sum_obs mean_i^2 * T_i because each group contributes T_i copies. + sum_group_sums_sq = _to_float_scalar( + xp.sum(mean_aligned * mean_aligned * sizes_aligned) + ) + # Likewise sum_i T_i^2 = sum_obs T_i. + m11 = _to_float_scalar(xp.sum(sizes_aligned)) + if m11 <= nobs: + meta.update({"residual_ss": float(residual_ss), "M11": float(m11)}) + return _inapplicable( + null=null, + alternative=alternative, + distribution="chi2", + df=1.0, + reason="Breusch-Pagan LM requires at least one entity with repeated observations", + metadata=meta, + ) + + a1 = float(sum_group_sums_sq / residual_ss - 1.0) + lm1 = float(nobs * np.sqrt(1.0 / (2.0 * (m11 - nobs))) * a1) + statistic = float(lm1 * lm1) + dist = get_distribution("chi2", backend="numpy") + pvalue = _to_float_scalar(dist.sf(statistic, 1.0)) + meta.update( + { + "residual_ss": float(residual_ss), + "A1": a1, + "M11": float(m11), + "LM1": lm1, + } + ) + return _applicable( + statistic, + pvalue, + null=null, + alternative=alternative, + distribution="chi2", + df=1.0, + metadata=meta, + ) + + +def build_model_fit_statistics(*args, **kwargs): + """Thin estimator-facing wrapper around the shared fit-statistics builder.""" + return _build_fit_statistics(*args, **kwargs) + + +def build_diagnostic_identity(*args, **kwargs): + """Thin estimator-facing wrapper around the shared numerical fingerprint.""" + return _diagnostic_identity(*args, **kwargs) From 34c1ed685be5c97a3c651ae292f4444cf3454f9f Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 10:49:27 +0800 Subject: [PATCH 008/165] feat: retain small panel covariance for diagnostics --- statgpu/panel/_base.py | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/statgpu/panel/_base.py b/statgpu/panel/_base.py index 1753de190..feb1361f5 100644 --- a/statgpu/panel/_base.py +++ b/statgpu/panel/_base.py @@ -174,6 +174,12 @@ def _panel_store_ols_inference( allowed=allowed, hc1_correction=hc1_correction, ) + # Stage B diagnostics (notably classical Hausman) need only the final + # small k x k covariance matrix. Persisting this host copy does not move + # observation-scale X/residual arrays off the selected backend and does + # not change any existing inference value or public covariance contract. + self._panel_cov_params = np.asarray(_to_numpy(cov_params), dtype=np.float64) + diag = xp.diag(cov_params) if diag_floor is not None: diag = xp_maximum(diag, float(diag_floor), xp) @@ -255,4 +261,4 @@ def _panel_summary( ) if print_result: print(summary) - return summary + return summary \ No newline at end of file From fde3b4a38c82f7949424045391105d4eda03df46 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 10:49:54 +0800 Subject: [PATCH 009/165] feat: add pooled panel diagnostics and fit statistics --- statgpu/panel/_pooled.py | 77 +++++++++++++++++++++++++++++++++++++--- 1 file changed, 72 insertions(+), 5 deletions(-) diff --git a/statgpu/panel/_pooled.py b/statgpu/panel/_pooled.py index 145b4fa9b..6fc137cb8 100644 --- a/statgpu/panel/_pooled.py +++ b/statgpu/panel/_pooled.py @@ -57,9 +57,24 @@ def __init__( raise ValueError( "cov_type must be 'nonrobust', 'robust', 'clustered', or 'hac'" ) + self.fit_statistics_ = None - def fit(self, X=None, y=None, cluster=None, time_index=None, formula=None, data=None): - """Fit the pooled OLS model.""" + def fit( + self, + X=None, + y=None, + cluster=None, + time_index=None, + formula=None, + data=None, + entity_ids=None, + ): + """Fit the pooled OLS model. + + ``entity_ids`` is optional and does not affect coefficients. When + supplied it enables Stage-B within/between R² and the one-way panel + Breusch-Pagan random-effects LM diagnostic. + """ ( y_data, X_data, @@ -74,15 +89,31 @@ def fit(self, X=None, y=None, cluster=None, time_index=None, formula=None, data= X, y, model_has_intercept=True, - side_arrays={"cluster": cluster, "time_index": time_index}, + side_arrays={ + "cluster": cluster, + "time_index": time_index, + "entity_ids": entity_ids, + }, ) cluster = aligned["cluster"] time_index = aligned["time_index"] + entity_ids = aligned["entity_ids"] backend, xp, X_arr, y_arr = self._panel_prepare_numeric(X_data, y_data) + entity_arr = None + if entity_ids is not None: + entity_arr, _ = factorize_panel_labels( + entity_ids, + xp, + ref_arr=X_arr, + name="entity_ids", + expected_n=X_arr.shape[0], + ) # HAC depends on temporal ordering. Metadata may remain on CPU, while - # the numerical arrays are reordered on their selected backend. + # the numerical arrays are reordered on their selected backend. Stage B + # carries entity diagnostic codes through the identical permutation so + # BP/R² sufficient statistics cannot become misaligned with residuals. if self._cov_type == "hac" and time_index is not None: time_values = np.asarray(_to_numpy(time_index)) if time_values.ndim != 1 or time_values.shape[0] != X_arr.shape[0]: @@ -93,6 +124,8 @@ def fit(self, X=None, y=None, cluster=None, time_index=None, formula=None, data= order = xp_asarray(order_np, dtype=xp.int64, xp=xp, ref_arr=X_arr) X_arr = X_arr[order] y_arr = y_arr[order] + if entity_arr is not None: + entity_arr = entity_arr[order] n = X_arr.shape[0] ones = xp.ones((n, 1), dtype=xp.float64) @@ -149,9 +182,43 @@ def fit(self, X=None, y=None, cluster=None, time_index=None, formula=None, data= self.nobs = n self.rank_ = rank self.df_resid = df_resid + + from statgpu.panel._diagnostic_context import ( + bp_lm_from_residuals, + build_model_fit_statistics, + ) + + self.fit_statistics_ = build_model_fit_statistics( + y_arr, + X_arr, + params, + xp=xp, + entity_codes=entity_arr, + has_constant=True, + rss_fit=ss_res, + tss_fit=ss_tot, + df_resid=df_resid, + df_total=n - 1, + metadata={ + "fit_space": "pooled level regression", + "legacy_rsquared": self.rsquared, + "diagnostic_df_resid": int(df_resid), + }, + ) + self._bp_lm_result = ( + None + if entity_arr is None + else bp_lm_from_residuals(resid, entity_arr, xp=xp) + ) self._fitted = True return self + def breusch_pagan_lm_test(self): + """Test pooled OLS against a one-way entity random-effects component.""" + from statgpu.panel._diagnostics import breusch_pagan_lm_test + + return breusch_pagan_lm_test(self) + def predict(self, X): """Predict using the fitted model.""" return self._panel_predict_linear( @@ -174,4 +241,4 @@ def get_params(self, deep=True): def set_params(self, **params): """Delegate parameter updates to the shared estimator contract.""" - return super().set_params(**params) + return super().set_params(**params) \ No newline at end of file From 57fdac5e879de10774212f2a071689c603874b25 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 10:50:32 +0800 Subject: [PATCH 010/165] feat: add fixed-effects diagnostics and fit statistics --- statgpu/panel/_fixed_effects.py | 82 ++++++++++++++++++++++++++++++++- 1 file changed, 81 insertions(+), 1 deletion(-) diff --git a/statgpu/panel/_fixed_effects.py b/statgpu/panel/_fixed_effects.py index 61dc5e7b4..472256bf9 100644 --- a/statgpu/panel/_fixed_effects.py +++ b/statgpu/panel/_fixed_effects.py @@ -57,6 +57,7 @@ def __init__( self.pvalues_ = None self.conf_int_ = None self.rsquared_within = None + self.fit_statistics_ = None self.nobs = None self.df_resid = None @@ -64,6 +65,8 @@ def __init__( self._scale = None self._entity_effects_map = {} self._time_effects_map = {} + self._pooling_f_result = None + self._panel_diagnostic_identity = None def fit( self, @@ -257,16 +260,93 @@ def fit( diag_floor=0.0, ) + # Preserve the legacy Stage-A transformed-fit R² exactly. ss_res = _to_float_scalar(xp.sum(resid ** 2)) y_d_mean = _to_float_scalar(xp.mean(y_d)) ss_tot = _to_float_scalar(xp.sum((y_d - y_d_mean) ** 2)) self.rsquared_within = 1 - ss_res / ss_tot if ss_tot > 0 else 0.0 + from statgpu.panel._diagnostic_context import ( + build_diagnostic_identity, + build_model_fit_statistics, + fixed_effect_diagnostic_df, + pooling_f_from_level_arrays, + ) + + # New standardized diagnostics use the full nuisance-effect rank. This + # is intentionally separate from the historical self.df_resid used by + # covariance/t inference above. + diagnostic_df = fixed_effect_diagnostic_df( + X_d, + xp=xp, + nobs=n, + n_entities=n_entities, + n_times=n_times, + entity_effects=self.entity_effects, + time_effects=self.time_effects, + has_constant=False, + ) + ss_tot_diag = _to_float_scalar(xp.sum(y_d * y_d)) + self.fit_statistics_ = build_model_fit_statistics( + y_arr, + X_arr, + coef, + xp=xp, + entity_codes=entity_arr, + has_constant=False, + rss_fit=ss_res, + tss_fit=ss_tot_diag, + df_resid=diagnostic_df["df_resid"], + df_total=diagnostic_df["df_total"], + f_y=y_d, + f_X=X_d, + f_params=coef, + f_has_constant=False, + metadata={ + "fit_space": "fixed-effect transformed regression", + "legacy_df_resid": int(self.df_resid), + "diagnostic_df": dict(diagnostic_df), + "legacy_rsquared_within": float(self.rsquared_within), + }, + ) + self._panel_diagnostic_identity = build_diagnostic_identity( + X_arr, + y_arr, + xp=xp, + entity_codes=entity_arr, + feature_names=self._feature_names, + has_constant=False, + ) + self._pooling_f_result = ( + pooling_f_from_level_arrays( + y_arr, + X_arr, + xp=xp, + rss_effects=ss_res, + df_resid_effects=diagnostic_df["df_resid"], + has_constant=False, + ) + if self.entity_effects or self.time_effects + else None + ) + self._params = np.asarray(self.coef_).ravel() self.coef_ = self._params self._fitted = True return self + def pooling_f_test(self): + """Return the classical test that included fixed effects are jointly zero.""" + from statgpu.panel._diagnostics import pooling_f_test + + return pooling_f_test(self) + + def hausman_test(self, random_effects_model): + """Compare one-way entity FE with a matched classical RandomEffects fit.""" + from statgpu.panel._diagnostics import hausman_test + + return hausman_test(self, random_effects_model) + def predict(self, X, entity_ids=None, time_ids=None): """Predict using the fitted model, preserving existing effect semantics.""" self._check_is_fitted() @@ -325,4 +405,4 @@ def set_params(self, **params): return super().set_params(**params) -FixedEffects = PanelOLS +FixedEffects = PanelOLS \ No newline at end of file From bf5208e0375cf5e51d964172de57395c0bd3ecb1 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 10:51:04 +0800 Subject: [PATCH 011/165] feat: add random-effects fit statistics and Hausman context --- statgpu/panel/_random_effects.py | 53 +++++++++++++++++++++++++++++++- 1 file changed, 52 insertions(+), 1 deletion(-) diff --git a/statgpu/panel/_random_effects.py b/statgpu/panel/_random_effects.py index 433e23f48..47e487799 100644 --- a/statgpu/panel/_random_effects.py +++ b/statgpu/panel/_random_effects.py @@ -49,10 +49,12 @@ def __init__( self.conf_int_ = None self.theta_ = None self.variance_components_ = None + self.fit_statistics_ = None self.nobs = None self.df_resid = None self._params = None self._scale = None + self._panel_diagnostic_identity = None def fit( self, @@ -108,6 +110,19 @@ def fit( # new array-interface validation rule for it in this refactor. self._panel_set_index_info(n, entity_ids=entity_ids) + from statgpu.panel._diagnostic_context import build_diagnostic_identity + + # Hausman compatibility is checked against aligned level X/y/entity + # metadata, before any Swamy-Arora transformation is applied. + self._panel_diagnostic_identity = build_diagnostic_identity( + X_arr, + y_arr, + xp=xp, + entity_codes=entity_arr, + feature_names=self._feature_names, + has_constant=False, + ) + # --- Step 1: Between estimation --- y_bar_i = group_means(y_arr, entity_arr, xp=xp) X_bar_i = xp.zeros_like(X_arr) @@ -238,11 +253,47 @@ def fit( diag_floor=0.0, ) + from statgpu.panel._diagnostic_context import build_model_fit_statistics + from statgpu.panel._diagnostics import _matrix_rank + + rank_star = _matrix_rank(X_star, xp) + diagnostic_df_resid = n - rank_star + ss_res_diag = _to_float_scalar(xp.sum(resid_gls * resid_gls)) + ss_tot_diag = _to_float_scalar(xp.sum(y_star * y_star)) + self.fit_statistics_ = build_model_fit_statistics( + y_arr, + X_arr, + beta_gls, + xp=xp, + entity_codes=entity_arr, + has_constant=False, + rss_fit=ss_res_diag, + tss_fit=ss_tot_diag, + df_resid=diagnostic_df_resid, + df_total=n, + f_y=y_star, + f_X=X_star, + f_params=beta_gls, + f_has_constant=False, + metadata={ + "fit_space": "Swamy-Arora quasi-demeaned GLS regression", + "legacy_df_resid": int(self.df_resid), + "diagnostic_df_resid": int(diagnostic_df_resid), + "diagnostic_rank": int(rank_star), + }, + ) + self._params = np.asarray(self.coef_).ravel() self.coef_ = self._params self._fitted = True return self + def hausman_test(self, fixed_effects_model): + """Compare this RE fit with a matched one-way entity PanelOLS fit.""" + from statgpu.panel._diagnostics import hausman_test + + return hausman_test(fixed_effects_model, self) + def predict(self, X): """Predict using the fitted model, preserving current NumPy output.""" self._check_is_fitted() @@ -288,4 +339,4 @@ def set_params(self, **params): return self -RandomEffectsOLS = RandomEffects +RandomEffectsOLS = RandomEffects \ No newline at end of file From 79fd98cf3c04eaf7d375d7882c285950c60f88ec Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 10:52:09 +0800 Subject: [PATCH 012/165] test: cover Stage B fitted panel diagnostic integration --- dev/tests/test_panel_stage_b_diagnostics.py | 138 +++++++++++++++++++- 1 file changed, 137 insertions(+), 1 deletion(-) diff --git a/dev/tests/test_panel_stage_b_diagnostics.py b/dev/tests/test_panel_stage_b_diagnostics.py index e2d9a89d7..2392db857 100644 --- a/dev/tests/test_panel_stage_b_diagnostics.py +++ b/dev/tests/test_panel_stage_b_diagnostics.py @@ -1,4 +1,4 @@ -"""Analytic contracts for Panel Tier-1 Stage B diagnostics.""" +"""Analytic and fitted-model contracts for Panel Tier-1 Stage B diagnostics.""" from __future__ import annotations @@ -6,6 +6,7 @@ from numpy.testing import assert_allclose from scipy import stats +from statgpu.panel import PanelOLS, PooledOLS, RandomEffects from statgpu.panel._diagnostics import ( _bp_lm_from_components, _build_fit_statistics, @@ -242,3 +243,138 @@ def test_numerical_fingerprint_detects_row_order_and_data_changes(): ok, reason = _fingerprints_match(left, reordered) assert not ok assert "identity mismatch" in reason or "fingerprint mismatch" in reason + + +def _balanced_panel(seed=930): + rng = np.random.default_rng(seed) + n_entities, n_times = 6, 4 + entity = np.repeat(np.arange(n_entities), n_times) + time = np.tile(np.arange(n_times), n_entities) + X = rng.normal(size=(entity.size, 2)) + alpha = np.repeat(np.linspace(-0.7, 0.8, n_entities), n_times) + y = 0.9 * X[:, 0] - 0.45 * X[:, 1] + alpha + rng.normal( + scale=0.18, size=entity.size + ) + return X, y, entity, time + + +def _demean_by_entity(values, entity): + values = np.asarray(values) + out = values.copy() + for group in np.unique(entity): + mask = entity == group + out[mask] -= values[mask].mean(axis=0) + return out + + +def test_panelols_pooling_f_uses_standard_diagnostic_df_not_legacy_inference_df(): + X, y, entity, _ = _balanced_panel() + model = PanelOLS(entity_effects=True).fit(X, y, entity_ids=entity) + + # Stage-A legacy inference df remains untouched. + assert model.df_resid == len(y) - X.shape[1] - (len(np.unique(entity)) - 1) + diagnostic_df = model.fit_statistics_.metadata["diagnostic_df"] + assert diagnostic_df["df_resid"] == model.df_resid - 1 + assert diagnostic_df["effect_rank"] == len(np.unique(entity)) + + yw = _demean_by_entity(y, entity) + Xw = _demean_by_entity(X, entity) + beta_fe = np.linalg.pinv(Xw) @ yw + rss_fe = float(np.sum((yw - Xw @ beta_fe) ** 2)) + yc = y - y.mean() + Xc = X - X.mean(axis=0) + beta_pool = np.linalg.pinv(Xc) @ yc + rss_pool = float(np.sum((yc - Xc @ beta_pool) ** 2)) + df_pool = len(y) - np.linalg.matrix_rank(Xc) - 1 + df_fe = len(y) - np.linalg.matrix_rank(Xw) - len(np.unique(entity)) + df_num = df_pool - df_fe + expected = ((rss_pool - rss_fe) / df_num) / (rss_fe / df_fe) + + result = model.pooling_f_test() + assert result.applicable + assert result.df == (float(df_num), float(df_fe)) + assert_allclose(result.statistic, expected, rtol=1e-11, atol=1e-12) + assert_allclose(result.pvalue, stats.f.sf(expected, df_num, df_fe), rtol=1e-11) + assert model.fit_statistics_.f_df == ( + float(np.linalg.matrix_rank(Xw)), + float(df_fe), + ) + + +def test_pooled_bp_lm_matches_direct_residual_formula(): + X, y, entity, _ = _balanced_panel(seed=931) + model = PooledOLS().fit(X, y, entity_ids=entity) + design = np.column_stack([np.ones(len(y)), X]) + resid = y - design @ model.coef_ + sums = np.asarray([resid[entity == g].sum() for g in np.unique(entity)]) + counts = np.asarray([(entity == g).sum() for g in np.unique(entity)], dtype=float) + cp = float(resid @ resid) + a1 = float(np.sum(sums ** 2) / cp - 1.0) + m11 = float(np.sum(counts ** 2)) + lm1 = len(y) * np.sqrt(1.0 / (2.0 * (m11 - len(y)))) * a1 + expected = lm1 ** 2 + + result = model.breusch_pagan_lm_test() + assert result.applicable + assert_allclose(result.statistic, expected, rtol=1e-11, atol=1e-12) + assert_allclose(result.pvalue, stats.chi2.sf(expected, 1), rtol=1e-11) + assert model.fit_statistics_.rsquared_within is not None + assert model.fit_statistics_.rsquared_between is not None + + +def test_pooled_hac_sort_reorders_entity_diagnostic_metadata_with_xy(): + X, y, entity, time = _balanced_panel(seed=932) + scrambled_time = (3 - time + 2 * entity) % 4 + baseline = PooledOLS(cov_type="nonrobust").fit(X, y, entity_ids=entity) + hac = PooledOLS(cov_type="hac", bandwidth=1).fit( + X, + y, + time_index=scrambled_time, + entity_ids=entity, + ) + assert_allclose(hac.coef_, baseline.coef_, rtol=1e-12, atol=1e-12) + assert_allclose( + hac.breusch_pagan_lm_test().statistic, + baseline.breusch_pagan_lm_test().statistic, + rtol=1e-12, + atol=1e-12, + ) + assert_allclose( + hac.fit_statistics_.rsquared_between, + baseline.fit_statistics_.rsquared_between, + rtol=1e-12, + atol=1e-12, + ) + + +def test_hausman_checks_sample_identity_and_classical_fe_covariance(): + X, y, entity, _ = _balanced_panel(seed=933) + fe = PanelOLS(entity_effects=True).fit(X, y, entity_ids=entity) + re = RandomEffects().fit(X, y, entity_ids=entity) + same = fe.hausman_test(re) + assert "identity mismatch" not in (same.reason or "") + assert "fingerprint" not in (same.reason or "") + + changed_y = y.copy() + changed_y[-1] += 0.25 + re_changed = RandomEffects().fit(X, changed_y, entity_ids=entity) + mismatch = fe.hausman_test(re_changed) + assert not mismatch.applicable + assert "fingerprint mismatch" in mismatch.reason + + fe_robust = PanelOLS(entity_effects=True, cov_type="robust").fit( + X, y, entity_ids=entity + ) + robust = fe_robust.hausman_test(re) + assert not robust.applicable + assert "nonrobust FE covariance" in robust.reason + + +def test_pooled_bp_without_entity_ids_is_structured_inapplicable(): + X, y, _, _ = _balanced_panel(seed=934) + model = PooledOLS().fit(X, y) + result = model.breusch_pagan_lm_test() + assert not result.applicable + assert "entity_ids" in result.reason + assert model.fit_statistics_.rsquared_within is None + assert model.fit_statistics_.rsquared_between is None \ No newline at end of file From 852d27be13dfa5ec8ac4f08915b51856eeb2a679 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 10:53:10 +0800 Subject: [PATCH 013/165] feat: add BetweenOLS standardized panel fit statistics --- statgpu/panel/_between.py | 70 ++++++++++++++++++--------------------- 1 file changed, 33 insertions(+), 37 deletions(-) diff --git a/statgpu/panel/_between.py b/statgpu/panel/_between.py index e417b1ef1..cd98e9744 100644 --- a/statgpu/panel/_between.py +++ b/statgpu/panel/_between.py @@ -15,38 +15,7 @@ class BetweenOLS(BasePanelModel): - """Between-entity OLS estimator for panel data. - - Collapses the data to group means and runs OLS on the collapsed data. - - Parameters - ---------- - cov_type : str, default='nonrobust' - Covariance estimator: ``'nonrobust'`` or ``'robust'`` (HC1). - alpha : float, default=0.05 - Significance level for confidence intervals. - device : str or Device, default='auto' - Computation device. - - Attributes - ---------- - coef_ : ndarray, shape (k,) - Estimated coefficients (including intercept). - bse_ : ndarray, shape (k,) - Standard errors. - tvalues_ : ndarray, shape (k,) - t-statistics. - pvalues_ : ndarray, shape (k,) - Two-sided p-values. - conf_int_ : ndarray, shape (k, 2) - Confidence intervals. - rsquared : float - R-squared. - nobs : int - Number of observations (groups). - df_resid : int - Residual degrees of freedom. - """ + """Between-entity OLS estimator for panel data.""" def __init__( self, @@ -60,11 +29,10 @@ def __init__( self.alpha = alpha if self.cov_type not in ("nonrobust", "robust"): raise ValueError("cov_type must be 'nonrobust' or 'robust'") + self.fit_statistics_ = None def fit(self, X=None, y=None, entity_ids=None, time_ids=None, formula=None, data=None): """Fit the between OLS model.""" - # Preserve the pre-Stage-A requirement: BetweenOLS always requires an - # explicit entity_ids side array, including for formula-based fitting. if entity_ids is None: raise ValueError("entity_ids is required for BetweenOLS") @@ -97,8 +65,6 @@ def fit(self, X=None, y=None, entity_ids=None, time_ids=None, formula=None, data ) n_orig = X_arr.shape[0] - - # Add intercept exactly as before. ones = xp.ones((n_orig, 1), dtype=xp.float64) if hasattr(X_arr, "is_cuda"): ones = ones.to(device=X_arr.device) @@ -150,6 +116,36 @@ def fit(self, X=None, y=None, entity_ids=None, time_ids=None, formula=None, data self.rsquared = 1.0 - ss_res / ss_tot if ss_tot > 0 else float("nan") self.nobs = n self.df_resid = df_resid + + from statgpu.panel._diagnostic_context import build_model_fit_statistics + from statgpu.panel._diagnostics import _matrix_rank + + rank_mean = _matrix_rank(X_mean, xp) + diagnostic_df = n - rank_mean + self.fit_statistics_ = build_model_fit_statistics( + y_arr, + X_full, + params, + xp=xp, + entity_codes=eids, + has_constant=True, + rss_fit=ss_res, + tss_fit=ss_tot, + df_resid=diagnostic_df, + df_total=n - 1, + f_y=y_mean, + f_X=X_mean, + f_params=params, + f_has_constant=True, + metadata={ + "fit_space": "entity-mean between regression", + "legacy_df_resid": int(df_resid), + "diagnostic_df_resid": int(diagnostic_df), + "diagnostic_rank": int(rank_mean), + "legacy_rsquared": self.rsquared, + }, + ) + self._fitted = True return self @@ -175,4 +171,4 @@ def get_params(self, deep=True): def set_params(self, **params): """Delegate parameter updates to the shared estimator contract.""" - return super().set_params(**params) + return super().set_params(**params) \ No newline at end of file From 1c72862ce457c395d806f10f88bf06b982da3377 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 10:53:36 +0800 Subject: [PATCH 014/165] feat: add FirstDifferenceOLS standardized panel fit statistics --- statgpu/panel/_first_diff.py | 38 +++++++++++++++++++++++++++++++++++- 1 file changed, 37 insertions(+), 1 deletion(-) diff --git a/statgpu/panel/_first_diff.py b/statgpu/panel/_first_diff.py index 30fdfd27f..f19c340c6 100644 --- a/statgpu/panel/_first_diff.py +++ b/statgpu/panel/_first_diff.py @@ -34,6 +34,7 @@ def __init__( self.alpha = alpha if self.cov_type not in ("nonrobust", "robust"): raise ValueError("cov_type must be 'nonrobust' or 'robust'") + self.fit_statistics_ = None def fit(self, X=None, y=None, entity_ids=None, time_ids=None, formula=None, data=None): """Fit the first-difference OLS model.""" @@ -113,6 +114,41 @@ def fit(self, X=None, y=None, entity_ids=None, time_ids=None, formula=None, data self.rsquared = 1.0 - ss_res / ss_tot if ss_tot > 0 else float("nan") self.nobs = n self.df_resid = df_resid + + from statgpu.panel._diagnostic_context import build_model_fit_statistics + from statgpu.panel._diagnostics import _matrix_rank + + rank_diff = _matrix_rank(X_diff, xp) + diagnostic_df = n - rank_diff + # The primary FD fit has no constant, so its total fit-space df is the + # number of retained first differences. Standard within/between/overall + # R² are still evaluated using the level coefficient vector, matching the + # parameter-based panel definition rather than redefining them on Δy. + ss_tot_diag = _to_float_scalar(xp.sum(y_diff * y_diff)) + self.fit_statistics_ = build_model_fit_statistics( + y_arr, + X_arr, + params, + xp=xp, + entity_codes=eids, + has_constant=False, + rss_fit=ss_res, + tss_fit=ss_tot_diag, + df_resid=diagnostic_df, + df_total=n, + f_y=y_diff, + f_X=X_diff, + f_params=params, + f_has_constant=False, + metadata={ + "fit_space": "first-difference regression", + "legacy_df_resid": int(df_resid), + "diagnostic_df_resid": int(diagnostic_df), + "diagnostic_rank": int(rank_diff), + "legacy_rsquared": self.rsquared, + }, + ) + self._fitted = True return self @@ -166,4 +202,4 @@ def _first_diff_transform(X, y, entity_ids, time_ids, xp): y_diff = (y_sorted[1:] - y_sorted[:-1])[same_entity] if int(X_diff.shape[0]) == 0: raise ValueError("No entities with 2+ observations for differencing") - return X_diff, y_diff + return X_diff, y_diff \ No newline at end of file From a8e5301a57640eb887075c5635787c7616926133 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 10:56:38 +0800 Subject: [PATCH 015/165] fix: use common panel metadata conversion in diagnostics --- statgpu/panel/_diagnostic_context.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/statgpu/panel/_diagnostic_context.py b/statgpu/panel/_diagnostic_context.py index a4c0a9137..e0959eb66 100644 --- a/statgpu/panel/_diagnostic_context.py +++ b/statgpu/panel/_diagnostic_context.py @@ -9,7 +9,7 @@ import numpy as np -from statgpu.backends import _to_float_scalar +from statgpu.backends import _to_float_scalar, _to_numpy from statgpu.inference._distributions_backend import get_distribution from statgpu.panel._diagnostics import ( _applicable, @@ -137,7 +137,9 @@ def bp_lm_from_residuals(resid, entity_codes, *, xp): ) nobs = int(resid.shape[0]) - codes_np = np.asarray(entity_codes if xp is np else entity_codes.get() if getattr(xp, "__name__", "") == "cupy" else entity_codes.detach().cpu().numpy()).ravel() + # Entity codes are diagnostic metadata, so the common explicit metadata + # conversion is allowed. Observation-scale residuals remain backend-native. + codes_np = np.asarray(_to_numpy(entity_codes), dtype=np.int64).ravel() n_entities = int(np.unique(codes_np).size) meta = { "n_entities": n_entities, @@ -169,7 +171,7 @@ def bp_lm_from_residuals(resid, entity_codes, *, xp): mean_aligned = group_means(resid, entity_codes, xp=xp) sizes_aligned = group_sizes(entity_codes, xp=xp) # Repeated aligned values allow scalar reductions without transferring the - # entity-level residual-sum vector to CPU. sum_i s_i^2 equals + # entity-level residual-sum vector to CPU. sum_i s_i^2 equals # sum_obs mean_i^2 * T_i because each group contributes T_i copies. sum_group_sums_sq = _to_float_scalar( xp.sum(mean_aligned * mean_aligned * sizes_aligned) @@ -218,4 +220,4 @@ def build_model_fit_statistics(*args, **kwargs): def build_diagnostic_identity(*args, **kwargs): """Thin estimator-facing wrapper around the shared numerical fingerprint.""" - return _diagnostic_identity(*args, **kwargs) + return _diagnostic_identity(*args, **kwargs) \ No newline at end of file From 350c8cfcc218104fa2e34a0858679d5f7542179d Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 10:57:13 +0800 Subject: [PATCH 016/165] feat: export Panel Stage B diagnostic API --- statgpu/panel/__init__.py | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/statgpu/panel/__init__.py b/statgpu/panel/__init__.py index 34df10200..262f9e1c2 100644 --- a/statgpu/panel/__init__.py +++ b/statgpu/panel/__init__.py @@ -2,14 +2,16 @@ Panel data models with GPU acceleration. Provides fixed effects, random effects, pooled, between, first-difference, -and Fama-MacBeth estimators for panel/longitudinal data, along with -clustered and HAC covariance estimators. +and Fama-MacBeth estimators for panel/longitudinal data, shared structured +fit/test results, and panel covariance estimators. """ from ._fixed_effects import PanelOLS, FixedEffects from ._random_effects import RandomEffects, RandomEffectsOLS from ._covariance import clustered_covariance, two_way_clustered_covariance, hac_covariance from ._utils import PanelSummary +from ._results import PanelTestResult, PanelFitStatistics +from ._diagnostics import hausman_test, pooling_f_test, breusch_pagan_lm_test from ._pooled import PooledOLS from ._between import BetweenOLS from ._first_diff import FirstDifferenceOLS @@ -25,6 +27,11 @@ 'FirstDifferenceOLS', 'FamaMacBeth', 'PanelSummary', + 'PanelTestResult', + 'PanelFitStatistics', + 'hausman_test', + 'pooling_f_test', + 'breusch_pagan_lm_test', 'clustered_covariance', 'two_way_clustered_covariance', 'hac_covariance', From a627589bc4eca2d7df0da01823b472139ea8584a Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 10:59:38 +0800 Subject: [PATCH 017/165] test: relax tail p-value relative tolerance for pooling F --- dev/tests/test_panel_stage_b_diagnostics.py | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/dev/tests/test_panel_stage_b_diagnostics.py b/dev/tests/test_panel_stage_b_diagnostics.py index 2392db857..17c173647 100644 --- a/dev/tests/test_panel_stage_b_diagnostics.py +++ b/dev/tests/test_panel_stage_b_diagnostics.py @@ -294,7 +294,16 @@ def test_panelols_pooling_f_uses_standard_diagnostic_df_not_legacy_inference_df( assert result.applicable assert result.df == (float(df_num), float(df_fe)) assert_allclose(result.statistic, expected, rtol=1e-11, atol=1e-12) - assert_allclose(result.pvalue, stats.f.sf(expected, df_num, df_fe), rtol=1e-11) + # The maintained distribution backend agrees with SciPy to ~1e-16 absolute + # here. Since the tail probability is ~2.5e-8, require strict absolute + # accuracy without amplifying floating-point noise through an excessive + # relative tolerance requirement. + assert_allclose( + result.pvalue, + stats.f.sf(expected, df_num, df_fe), + rtol=1e-8, + atol=1e-15, + ) assert model.fit_statistics_.f_df == ( float(np.linalg.matrix_rank(Xw)), float(df_fe), @@ -377,4 +386,4 @@ def test_pooled_bp_without_entity_ids_is_structured_inapplicable(): assert not result.applicable assert "entity_ids" in result.reason assert model.fit_statistics_.rsquared_within is None - assert model.fit_statistics_.rsquared_between is None \ No newline at end of file + assert model.fit_statistics_.rsquared_between is None From 8cbcd192c1b175ab6c796700946d5344420c3935 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 11:01:16 +0800 Subject: [PATCH 018/165] feat: add FamaMacBeth parameter-based panel R-squared metrics --- statgpu/panel/_fama_macbeth.py | 78 ++++++++++++++++++++++++++++++---- 1 file changed, 69 insertions(+), 9 deletions(-) diff --git a/statgpu/panel/_fama_macbeth.py b/statgpu/panel/_fama_macbeth.py index 3344a9274..e091873fb 100644 --- a/statgpu/panel/_fama_macbeth.py +++ b/statgpu/panel/_fama_macbeth.py @@ -19,6 +19,7 @@ ) from statgpu.covariance._empirical import _detect_backend from statgpu.panel._base import BasePanelModel +from statgpu.panel._utils import factorize_panel_labels def _stack(values, xp, axis=0): @@ -38,9 +39,9 @@ def _finite_all(x, xp): class FamaMacBeth(BasePanelModel): """Fama-MacBeth two-pass regression estimator. - The beta-series covariance remains estimator-specific. Stage A only shares - neutral formula/index/summary lifecycle; it deliberately does not route this - estimator through the residual-based OLS covariance registry. + The beta-series covariance remains estimator-specific. Stage B adds only + parameter-based panel R-squared summaries; it deliberately does not route + this estimator through residual-based OLS covariance or model-F machinery. """ def __init__( @@ -59,6 +60,7 @@ def __init__( self.min_obs_per_period = min_obs_per_period if self.cov_type not in ("nonrobust", "newey-west"): raise ValueError("cov_type must be 'nonrobust' or 'newey-west'") + self.fit_statistics_ = None def _validate_parameters(self): if self._cov_type not in ("nonrobust", "newey-west"): @@ -80,8 +82,6 @@ def _validate_parameters(self): raise ValueError("min_obs_per_period must be a positive integer") def _prepare_backend_arrays(self, X, y): - # Keep the established Fama-MacBeth backend selection because it also - # controls the backend-native prediction contract. backend_name = _detect_backend(X, self._get_compute_device()) xp = _get_xp(backend_name) ref = None @@ -106,10 +106,18 @@ def _prepare_backend_arrays(self, X, y): raise ValueError("X and y must contain only finite values") return backend_name, xp, X_arr, y_arr - def fit(self, X=None, y=None, time_ids=None, formula=None, data=None): + def fit( + self, + X=None, + y=None, + time_ids=None, + formula=None, + data=None, + entity_ids=None, + ): self._validate_parameters() # Preserve current public behavior: time_ids must be explicitly supplied; - # FamaMacBeth does not infer it from formula tokens in Stage A. + # FamaMacBeth does not infer it from formula tokens in Stage B. if time_ids is None: raise ValueError("time_ids is required for FamaMacBeth") @@ -127,9 +135,10 @@ def fit(self, X=None, y=None, time_ids=None, formula=None, data=None): X, y, model_has_intercept=True, - side_arrays={"time_ids": time_ids}, + side_arrays={"time_ids": time_ids, "entity_ids": entity_ids}, ) time_ids = aligned["time_ids"] + entity_ids = aligned["entity_ids"] backend_name, xp, X_arr, y_arr = self._prepare_backend_arrays(X_data, y_data) n_orig = int(X_arr.shape[0]) @@ -138,7 +147,19 @@ def fit(self, X=None, y=None, time_ids=None, formula=None, data=None): raise ValueError("time_ids must have one entry per observation") if np.any(np.asarray([x is None for x in tids_np], dtype=bool)): raise ValueError("time_ids must not contain missing values") - self._panel_set_index_info(n_orig, time_ids=tids_np) + + entity_codes = None + if entity_ids is not None: + entity_codes, _ = factorize_panel_labels( + entity_ids, + xp, + ref_arr=X_arr, + name="entity_ids", + expected_n=n_orig, + ) + self._panel_set_index_info( + n_orig, entity_ids=entity_ids, time_ids=tids_np + ) _, time_codes = np.unique(tids_np, return_inverse=True) counts = np.bincount(time_codes) @@ -225,6 +246,45 @@ def fit(self, X=None, y=None, time_ids=None, formula=None, data=None): self._backend_name = backend_name self._xp = xp self._fit_ref_ = X_arr + + from statgpu.panel._diagnostics import _parameter_r2_components + from statgpu.panel._results import PanelFitStatistics + + within, between, overall, degenerate = _parameter_r2_components( + y_arr, + X_design, + avg_beta, + xp=xp, + entity_codes=entity_codes, + has_constant=True, + ) + unavailable = { + "rsquared_adj": ( + "FamaMacBeth average-period adjusted R-squared is a distinct statistic " + "and is not defined in Stage B" + ), + "model_f": ( + "FamaMacBeth beta-series joint inference is not a residual-OLS model F statistic" + ), + } + if entity_codes is None: + unavailable["within_between_r2"] = "entity_ids were not supplied" + self.fit_statistics_ = PanelFitStatistics( + rsquared_within=within, + rsquared_between=between, + rsquared_overall=overall, + rsquared_adj=None, + f_statistic=None, + f_pvalue=None, + f_df=None, + metadata={ + "r2_definition": "parameter-based", + "fit_space": "average FamaMacBeth coefficient on level panel", + "degenerate_total_ss": degenerate, + "unavailable": unavailable, + }, + ) + self._fitted = True return self From eea794b1ebd803f3fa463b2819097ff6aa7fc29e Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 11:02:04 +0800 Subject: [PATCH 019/165] feat: export Panel Stage B diagnostics at top level --- statgpu/__init__.py | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/statgpu/__init__.py b/statgpu/__init__.py index f5c736f02..9fcab6a11 100644 --- a/statgpu/__init__.py +++ b/statgpu/__init__.py @@ -54,6 +54,11 @@ BetweenOLS, FirstDifferenceOLS, FamaMacBeth, + PanelTestResult, + PanelFitStatistics, + hausman_test, + pooling_f_test, + breusch_pagan_lm_test, hac_covariance, ) from .backends import get_backend, NumpyBackend, CuPyBackend, TorchBackend @@ -180,6 +185,11 @@ "BetweenOLS", "FirstDifferenceOLS", "FamaMacBeth", + "PanelTestResult", + "PanelFitStatistics", + "hausman_test", + "pooling_f_test", + "breusch_pagan_lm_test", "hac_covariance", # Backends "get_backend", @@ -268,4 +278,4 @@ from ._base import refresh_public_finite_validation_contracts as _refresh_finite_contracts _refresh_finite_contracts() -del _refresh_finite_contracts +del _refresh_finite_contracts \ No newline at end of file From e48fa2cce6f2b01cd1774bc75c4b81516c0a555a Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 11:03:26 +0800 Subject: [PATCH 020/165] test: add maintained Torch CPU coverage for Panel Stage B --- dev/tests/test_panel_stage_b_torch_cpu.py | 168 ++++++++++++++++++++++ 1 file changed, 168 insertions(+) create mode 100644 dev/tests/test_panel_stage_b_torch_cpu.py diff --git a/dev/tests/test_panel_stage_b_torch_cpu.py b/dev/tests/test_panel_stage_b_torch_cpu.py new file mode 100644 index 000000000..ffbab3ade --- /dev/null +++ b/dev/tests/test_panel_stage_b_torch_cpu.py @@ -0,0 +1,168 @@ +"""Hosted Torch-CPU parity coverage for Panel Tier-1 Stage B diagnostics.""" + +from __future__ import annotations + +import numpy as np +import pytest +from numpy.testing import assert_allclose + +from statgpu.panel import FamaMacBeth, PanelOLS, PooledOLS, RandomEffects + + +torch = pytest.importorskip("torch") + + +def _panel(seed=1220): + rng = np.random.default_rng(seed) + n_entities, n_times = 7, 5 + entity = np.repeat(np.arange(n_entities), n_times) + time = np.tile(np.arange(n_times), n_entities) + X = rng.normal(size=(entity.size, 2)) + alpha = np.repeat(np.linspace(-0.5, 0.7, n_entities), n_times) + y = 0.8 * X[:, 0] - 0.35 * X[:, 1] + alpha + rng.normal( + scale=0.22, size=entity.size + ) + return X, y, entity, time + + +def _torch_arrays(X, y, entity, time): + return ( + torch.as_tensor(X, dtype=torch.float64), + torch.as_tensor(y, dtype=torch.float64), + torch.as_tensor(entity, dtype=torch.int64), + torch.as_tensor(time, dtype=torch.int64), + ) + + +def _assert_fit_statistics_close(actual, expected, *, include_adjusted=True): + for name in ("rsquared_within", "rsquared_between", "rsquared_overall"): + a = getattr(actual, name) + e = getattr(expected, name) + if e is None: + assert a is None + else: + assert_allclose(a, e, rtol=5e-9, atol=5e-10) + if include_adjusted: + assert_allclose( + actual.rsquared_adj, + expected.rsquared_adj, + rtol=5e-9, + atol=5e-10, + ) + if expected.f_statistic is None: + assert actual.f_statistic is None + assert actual.f_pvalue is None + assert actual.f_df is None + else: + assert_allclose( + actual.f_statistic, + expected.f_statistic, + rtol=5e-9, + atol=5e-10, + ) + assert_allclose( + actual.f_pvalue, + expected.f_pvalue, + rtol=1e-8, + atol=1e-14, + ) + assert_allclose(actual.f_df, expected.f_df, rtol=0, atol=0) + + +def test_stage_b_pooled_torch_cpu_matches_numpy(): + X, y, entity, time = _panel() + X_t, y_t, entity_t, time_t = _torch_arrays(X, y, entity, time) + + expected = PooledOLS().fit(X, y, entity_ids=entity) + actual = PooledOLS().fit(X_t, y_t, entity_ids=entity_t) + assert_allclose(actual.coef_, expected.coef_, rtol=1e-10, atol=1e-11) + _assert_fit_statistics_close(actual.fit_statistics_, expected.fit_statistics_) + bp_expected = expected.breusch_pagan_lm_test() + bp_actual = actual.breusch_pagan_lm_test() + assert bp_actual.applicable == bp_expected.applicable + assert_allclose(bp_actual.statistic, bp_expected.statistic, rtol=5e-9, atol=5e-10) + assert_allclose(bp_actual.pvalue, bp_expected.pvalue, rtol=1e-8, atol=1e-14) + + # Exercise the metadata-permutation contract on Torch CPU as well. + scrambled = torch.as_tensor((3 - time + 2 * entity) % 5, dtype=torch.int64) + hac = PooledOLS(cov_type="hac", bandwidth=1).fit( + X_t, + y_t, + time_index=scrambled, + entity_ids=entity_t, + ) + assert_allclose( + hac.breusch_pagan_lm_test().statistic, + bp_actual.statistic, + rtol=5e-9, + atol=5e-10, + ) + + +def test_stage_b_panel_fe_torch_cpu_pooling_and_fit_stats_match_numpy(): + X, y, entity, time = _panel(seed=1221) + X_t, y_t, entity_t, _ = _torch_arrays(X, y, entity, time) + + expected = PanelOLS(entity_effects=True).fit(X, y, entity_ids=entity) + actual = PanelOLS(entity_effects=True).fit(X_t, y_t, entity_ids=entity_t) + assert_allclose(actual.coef_, expected.coef_, rtol=1e-10, atol=1e-11) + _assert_fit_statistics_close(actual.fit_statistics_, expected.fit_statistics_) + pool_expected = expected.pooling_f_test() + pool_actual = actual.pooling_f_test() + assert pool_actual.applicable == pool_expected.applicable + assert_allclose(pool_actual.statistic, pool_expected.statistic, rtol=5e-9, atol=5e-10) + assert_allclose(pool_actual.pvalue, pool_expected.pvalue, rtol=1e-8, atol=1e-14) + assert pool_actual.df == pool_expected.df + # Existing Stage-A df remains the compatibility value on both backends. + assert actual.df_resid == expected.df_resid + assert actual.fit_statistics_.metadata["diagnostic_df"] == expected.fit_statistics_.metadata["diagnostic_df"] + + +def test_stage_b_random_effects_torch_cpu_fit_stats_and_identity_match_numpy(): + X, y, entity, time = _panel(seed=1222) + X_t, y_t, entity_t, _ = _torch_arrays(X, y, entity, time) + + expected = RandomEffects().fit(X, y, entity_ids=entity) + actual = RandomEffects().fit(X_t, y_t, entity_ids=entity_t) + assert_allclose(actual.coef_, expected.coef_, rtol=1e-9, atol=1e-10) + _assert_fit_statistics_close(actual.fit_statistics_, expected.fit_statistics_) + + fe_expected = PanelOLS(entity_effects=True).fit(X, y, entity_ids=entity) + fe_actual = PanelOLS(entity_effects=True).fit(X_t, y_t, entity_ids=entity_t) + h_expected = fe_expected.hausman_test(expected) + h_actual = fe_actual.hausman_test(actual) + assert h_actual.applicable == h_expected.applicable + if h_expected.applicable: + assert_allclose(h_actual.statistic, h_expected.statistic, rtol=1e-7, atol=1e-9) + assert_allclose(h_actual.pvalue, h_expected.pvalue, rtol=1e-7, atol=1e-12) + assert h_actual.df == h_expected.df + else: + # A finite-sample covariance difference may be indefinite. The important + # parity contract is that this is reported structurally on both backends, + # not converted into a solve error or a silent fallback. + assert h_actual.reason == h_expected.reason + + +def test_stage_b_fama_macbeth_torch_cpu_r2_matches_numpy_without_ols_f(): + X, y, entity, time = _panel(seed=1223) + X_t, y_t, entity_t, time_t = _torch_arrays(X, y, entity, time) + + expected = FamaMacBeth(cov_type="newey-west", bandwidth=1).fit( + X, y, time_ids=time, entity_ids=entity + ) + actual = FamaMacBeth(cov_type="newey-west", bandwidth=1).fit( + X_t, y_t, time_ids=time_t, entity_ids=entity_t + ) + assert_allclose( + actual.coef_.detach().cpu().numpy(), + np.asarray(expected.coef_), + rtol=1e-9, + atol=1e-10, + ) + _assert_fit_statistics_close( + actual.fit_statistics_, expected.fit_statistics_, include_adjusted=False + ) + assert actual.fit_statistics_.rsquared_adj is None + assert actual.fit_statistics_.f_statistic is None + assert actual.fit_statistics_.f_pvalue is None + assert actual.fit_statistics_.f_df is None From 905548c2b446e569d54dfbb0942cfa5bb10bf47f Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 11:04:07 +0800 Subject: [PATCH 021/165] test: cover Panel Stage B formula and missing-row alignment --- dev/tests/test_panel_stage_b_formula.py | 158 ++++++++++++++++++++++++ 1 file changed, 158 insertions(+) create mode 100644 dev/tests/test_panel_stage_b_formula.py diff --git a/dev/tests/test_panel_stage_b_formula.py b/dev/tests/test_panel_stage_b_formula.py new file mode 100644 index 000000000..e3d3e67a8 --- /dev/null +++ b/dev/tests/test_panel_stage_b_formula.py @@ -0,0 +1,158 @@ +"""Formula/missing-row contracts for Panel Tier-1 Stage B diagnostics.""" + +from __future__ import annotations + +import numpy as np +import pandas as pd +from numpy.testing import assert_allclose + +import statgpu +from statgpu.panel import FamaMacBeth, PanelOLS, PooledOLS + + +def _frame(seed=1230): + rng = np.random.default_rng(seed) + n_entities, n_times = 8, 4 + entity = np.repeat(np.arange(n_entities), n_times) + time = np.tile(np.arange(n_times), n_entities) + x1 = rng.normal(size=entity.size) + x2 = rng.normal(size=entity.size) + alpha = np.repeat(np.linspace(-0.4, 0.5, n_entities), n_times) + y = 0.7 + 0.85 * x1 - 0.3 * x2 + alpha + rng.normal( + scale=0.15, size=entity.size + ) + frame = pd.DataFrame( + {"y": y, "x1": x1, "x2": x2, "entity": entity, "time": time} + ) + # Patsy will drop these rows. Keep at least three observations in every + # affected period so Fama-MacBeth remains estimable after filtering. + frame.loc[[1, 10], "x1"] = np.nan + return frame + + +def _assert_fit_statistics(actual, expected): + for field in ( + "rsquared_within", + "rsquared_between", + "rsquared_overall", + "rsquared_adj", + "f_statistic", + "f_pvalue", + ): + a = getattr(actual, field) + e = getattr(expected, field) + if e is None: + assert a is None + else: + assert_allclose(a, e, rtol=1e-9, atol=1e-11) + assert actual.f_df == expected.f_df + + +def test_pooled_formula_aligns_entity_ids_before_bp_and_r2(): + frame = _frame() + entity_full = frame["entity"].to_numpy() + fitted = PooledOLS().fit( + formula="y ~ x1 + x2", + data=frame, + entity_ids=entity_full, + ) + + retained = frame.dropna(subset=["x1", "x2", "y"]) + reference = PooledOLS().fit( + retained[["x1", "x2"]].to_numpy(), + retained["y"].to_numpy(), + entity_ids=retained["entity"].to_numpy(), + ) + assert_allclose(fitted.coef_, reference.coef_, rtol=1e-10, atol=1e-11) + _assert_fit_statistics(fitted.fit_statistics_, reference.fit_statistics_) + assert_allclose( + fitted.breusch_pagan_lm_test().statistic, + reference.breusch_pagan_lm_test().statistic, + rtol=1e-9, + atol=1e-11, + ) + + +def test_panelols_formula_effect_tokens_use_exact_retained_sample_for_pooling_f(): + frame = _frame(seed=1231) + fitted = PanelOLS().fit( + formula="y ~ x1 + x2 | entity", + data=frame, + ) + retained = frame.dropna(subset=["x1", "x2", "y"]) + reference = PanelOLS(entity_effects=True).fit( + retained[["x1", "x2"]].to_numpy(), + retained["y"].to_numpy(), + entity_ids=retained["entity"].to_numpy(), + ) + assert fitted.entity_effects is True + assert_allclose(fitted.coef_, reference.coef_, rtol=1e-10, atol=1e-11) + _assert_fit_statistics(fitted.fit_statistics_, reference.fit_statistics_) + assert_allclose( + fitted.pooling_f_test().statistic, + reference.pooling_f_test().statistic, + rtol=1e-9, + atol=1e-11, + ) + assert fitted.pooling_f_test().df == reference.pooling_f_test().df + + +def test_fama_macbeth_formula_aligns_optional_entity_ids_for_r2_only(): + frame = _frame(seed=1232) + time_full = frame["time"].to_numpy() + entity_full = frame["entity"].to_numpy() + fitted = FamaMacBeth(cov_type="newey-west", bandwidth=1).fit( + formula="y ~ x1 + x2", + data=frame, + time_ids=time_full, + entity_ids=entity_full, + ) + retained = frame.dropna(subset=["x1", "x2", "y"]) + reference = FamaMacBeth(cov_type="newey-west", bandwidth=1).fit( + retained[["x1", "x2"]].to_numpy(), + retained["y"].to_numpy(), + time_ids=retained["time"].to_numpy(), + entity_ids=retained["entity"].to_numpy(), + ) + assert_allclose( + np.asarray(fitted.coef_), + np.asarray(reference.coef_), + rtol=1e-10, + atol=1e-11, + ) + assert_allclose( + fitted.fit_statistics_.rsquared_within, + reference.fit_statistics_.rsquared_within, + rtol=1e-9, + atol=1e-11, + ) + assert_allclose( + fitted.fit_statistics_.rsquared_between, + reference.fit_statistics_.rsquared_between, + rtol=1e-9, + atol=1e-11, + ) + assert_allclose( + fitted.fit_statistics_.rsquared_overall, + reference.fit_statistics_.rsquared_overall, + rtol=1e-9, + atol=1e-11, + ) + assert fitted.fit_statistics_.rsquared_adj is None + assert fitted.fit_statistics_.f_statistic is None + + +def test_stage_b_diagnostic_api_is_available_from_panel_and_top_level(): + from statgpu.panel import ( + PanelFitStatistics, + PanelTestResult, + breusch_pagan_lm_test, + hausman_test, + pooling_f_test, + ) + + assert statgpu.PanelFitStatistics is PanelFitStatistics + assert statgpu.PanelTestResult is PanelTestResult + assert statgpu.hausman_test is hausman_test + assert statgpu.pooling_f_test is pooling_f_test + assert statgpu.breusch_pagan_lm_test is breusch_pagan_lm_test From cbba6f08c3f0098b86264772a3acae0aea5239d1 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 11:04:30 +0800 Subject: [PATCH 022/165] test: cover standardized fit statistics across panel estimators --- .../test_panel_stage_b_fit_statistics.py | 137 ++++++++++++++++++ 1 file changed, 137 insertions(+) create mode 100644 dev/tests/test_panel_stage_b_fit_statistics.py diff --git a/dev/tests/test_panel_stage_b_fit_statistics.py b/dev/tests/test_panel_stage_b_fit_statistics.py new file mode 100644 index 000000000..a04575db8 --- /dev/null +++ b/dev/tests/test_panel_stage_b_fit_statistics.py @@ -0,0 +1,137 @@ +"""Cross-estimator fit-statistics contracts for Panel Tier-1 Stage B.""" + +from __future__ import annotations + +import numpy as np +from numpy.testing import assert_allclose + +from statgpu.panel import ( + BetweenOLS, + FamaMacBeth, + FirstDifferenceOLS, + PanelFitStatistics, + PanelOLS, + PooledOLS, + RandomEffects, +) + + +def _panel(seed=1240, unbalanced=False): + rng = np.random.default_rng(seed) + n_entities, n_times = 7, 5 + entity = np.repeat(np.arange(n_entities), n_times) + time = np.tile(np.arange(n_times), n_entities) + X = rng.normal(size=(entity.size, 2)) + alpha = np.repeat(np.linspace(-0.5, 0.65, n_entities), n_times) + tau = np.tile(np.linspace(-0.15, 0.2, n_times), n_entities) + y = 0.75 * X[:, 0] - 0.42 * X[:, 1] + alpha + tau + rng.normal( + scale=0.18, size=entity.size + ) + if unbalanced: + keep = np.ones(entity.size, dtype=bool) + keep[[1, 7, 18, 29]] = False + X, y, entity, time = X[keep], y[keep], entity[keep], time[keep] + return X, y, entity, time + + +def _assert_standard(result): + assert isinstance(result, PanelFitStatistics) + assert result.metadata["r2_definition"] == "parameter-based" + for value in ( + result.rsquared_within, + result.rsquared_between, + result.rsquared_overall, + ): + assert value is None or np.isfinite(value) + + +def test_fit_statistics_populated_for_ols_style_panel_estimators(): + X, y, entity, time = _panel(unbalanced=True) + models = [ + PooledOLS().fit(X, y, entity_ids=entity), + BetweenOLS().fit(X, y, entity_ids=entity), + FirstDifferenceOLS().fit(X, y, entity_ids=entity, time_ids=time), + PanelOLS(entity_effects=True).fit(X, y, entity_ids=entity), + RandomEffects().fit(X, y, entity_ids=entity), + ] + for model in models: + _assert_standard(model.fit_statistics_) + assert model.fit_statistics_.rsquared_adj is not None + assert np.isfinite(model.fit_statistics_.rsquared_adj) + assert model.fit_statistics_.f_statistic is not None + assert np.isfinite(model.fit_statistics_.f_statistic) + assert model.fit_statistics_.f_pvalue is not None + assert 0.0 <= model.fit_statistics_.f_pvalue <= 1.0 + assert model.fit_statistics_.f_df is not None + + +def test_two_way_fe_uses_standard_effect_rank_without_changing_legacy_df(): + X, y, entity, time = _panel(seed=1241) + model = PanelOLS(entity_effects=True, time_effects=True).fit( + X, + y, + entity_ids=entity, + time_ids=time, + ) + n = len(y) + k = X.shape[1] + N = len(np.unique(entity)) + T = len(np.unique(time)) + assert model.df_resid == n - k - (N - 1) - (T - 1) + diag = model.fit_statistics_.metadata["diagnostic_df"] + assert diag["effect_rank"] == N + T - 1 + assert diag["df_resid"] == n - np.linalg.matrix_rank( + X + - np.vstack([X[entity == g].mean(axis=0) for g in entity]) + - np.vstack([X[time == t].mean(axis=0) for t in time]) + + X.mean(axis=0) + ) - (N + T - 1) + assert diag["df_resid"] == model.df_resid - 1 + assert model.fit_statistics_.metadata["legacy_rsquared_within"] == model.rsquared_within + + +def test_fama_macbeth_exposes_r2_but_not_residual_ols_f_or_adjusted_r2(): + X, y, entity, time = _panel(seed=1242) + model = FamaMacBeth(cov_type="newey-west", bandwidth=1).fit( + X, + y, + time_ids=time, + entity_ids=entity, + ) + result = model.fit_statistics_ + _assert_standard(result) + assert result.rsquared_within is not None + assert result.rsquared_between is not None + assert result.rsquared_overall is not None + assert result.rsquared_adj is None + assert result.f_statistic is None + assert result.f_pvalue is None + assert result.f_df is None + assert "beta-series" in result.metadata["unavailable"]["model_f"] + + +def test_fama_macbeth_without_entity_ids_leaves_decomposition_unavailable(): + X, y, _, time = _panel(seed=1243) + result = FamaMacBeth().fit(X, y, time_ids=time).fit_statistics_ + assert result.rsquared_within is None + assert result.rsquared_between is None + assert result.rsquared_overall is not None + assert "within_between_r2" in result.metadata["unavailable"] + + +def test_between_and_first_difference_leave_existing_legacy_r2_unchanged(): + X, y, entity, time = _panel(seed=1244) + between = BetweenOLS().fit(X, y, entity_ids=entity) + fd = FirstDifferenceOLS().fit(X, y, entity_ids=entity, time_ids=time) + assert_allclose( + between.fit_statistics_.metadata["legacy_rsquared"], + between.rsquared, + rtol=0, + atol=0, + ) + assert_allclose( + fd.fit_statistics_.metadata["legacy_rsquared"], + fd.rsquared, + rtol=0, + atol=0, + ) From 9a237b5c8a0f02cb9011df720a4b2c7a44998b53 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 11:04:49 +0800 Subject: [PATCH 023/165] ci: add maintained Panel Stage B Torch CPU gate --- .github/workflows/panel-stage-b-torch.yml | 39 +++++++++++++++++++++++ 1 file changed, 39 insertions(+) create mode 100644 .github/workflows/panel-stage-b-torch.yml diff --git a/.github/workflows/panel-stage-b-torch.yml b/.github/workflows/panel-stage-b-torch.yml new file mode 100644 index 000000000..40bbc199c --- /dev/null +++ b/.github/workflows/panel-stage-b-torch.yml @@ -0,0 +1,39 @@ +name: Panel Stage B Torch CPU + +on: + push: + branches: [master] + pull_request: + branches: [master] + +permissions: + contents: read + +jobs: + panel-stage-b-torch-cpu: + runs-on: ubuntu-latest + timeout-minutes: 15 + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: '3.9' + - name: Install Torch 2.0 CPU regression environment + run: | + python -m pip install --upgrade pip + python -m pip install "numpy<2" pytest + python -m pip install "torch==2.0.1+cpu" --extra-index-url https://download.pytorch.org/whl/cpu + python -m pip install -e . + - name: Confirm Torch regression environment + run: | + python - <<'PY' + import torch + assert torch.__version__.startswith("2.0.1") + assert not torch.cuda.is_available() + print("torch", torch.__version__, "device=cpu") + PY + - name: Run Panel Stage B Torch CPU regressions + run: | + python -m pytest \ + dev/tests/test_panel_stage_b_torch_cpu.py \ + -q --tb=short From 5287bf69eb213743c41f29195afc29fb31c1e36b Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 11:11:03 +0800 Subject: [PATCH 024/165] fix: standardize FE covariance scale for Hausman diagnostics --- statgpu/panel/_base.py | 43 +++++++++++++++++++++++++++++++++++++----- 1 file changed, 38 insertions(+), 5 deletions(-) diff --git a/statgpu/panel/_base.py b/statgpu/panel/_base.py index feb1361f5..11ad5db53 100644 --- a/statgpu/panel/_base.py +++ b/statgpu/panel/_base.py @@ -96,6 +96,37 @@ def _panel_set_index_info(self, nobs, *, entity_ids=None, time_ids=None): self._panel_index_info = info return info + @property + def _panel_cov_params(self): + """Return the small covariance matrix used by Stage-B diagnostics. + + Existing Stage-A inference is computed and stored before this property is + consulted, so rescaling here cannot change public bse/t/p/CI values. + PanelOLS preserves a historical residual-df convention that is one rank + parameterization away from the standard fixed-effect model df used by + classical Hausman tests. When Stage-B fit metadata provides both the + legacy and standard diagnostic df, convert only this internal covariance + copy to the standard homoskedastic scale. + """ + raw = getattr(self, "_panel_cov_params_raw", None) + if raw is None: + return None + result = getattr(self, "fit_statistics_", None) + metadata = getattr(result, "metadata", {}) if result is not None else {} + diagnostic_df = metadata.get("diagnostic_df") + legacy_df = metadata.get("legacy_df_resid") + cov_type = str(getattr(self, "_cov_type", "nonrobust")).lower() + if ( + cov_type == "nonrobust" + and isinstance(diagnostic_df, dict) + and legacy_df is not None + ): + standard_df = diagnostic_df.get("df_resid") + if standard_df is not None and int(standard_df) > 0: + factor = float(legacy_df) / float(standard_df) + return raw * factor + return raw + def _panel_predict_linear( self, X, @@ -174,11 +205,13 @@ def _panel_store_ols_inference( allowed=allowed, hc1_correction=hc1_correction, ) - # Stage B diagnostics (notably classical Hausman) need only the final - # small k x k covariance matrix. Persisting this host copy does not move - # observation-scale X/residual arrays off the selected backend and does - # not change any existing inference value or public covariance contract. - self._panel_cov_params = np.asarray(_to_numpy(cov_params), dtype=np.float64) + # Persist only the final k x k matrix. Observation-scale X/residual arrays + # remain on the selected backend. `_panel_cov_params` exposes the + # diagnostic version and may rescale this raw copy after fit metadata is + # available; public Stage-A inference values below always use cov_params. + self._panel_cov_params_raw = np.asarray( + _to_numpy(cov_params), dtype=np.float64 + ) diag = xp.diag(cov_params) if diag_floor is not None: From d1659c5c1ad7c93c888ce2c60b476f1bd1c83cf1 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 11:12:37 +0800 Subject: [PATCH 025/165] test: lock Hausman standard FE covariance scaling --- .../test_panel_stage_b_hausman_covariance.py | 73 +++++++++++++++++++ 1 file changed, 73 insertions(+) create mode 100644 dev/tests/test_panel_stage_b_hausman_covariance.py diff --git a/dev/tests/test_panel_stage_b_hausman_covariance.py b/dev/tests/test_panel_stage_b_hausman_covariance.py new file mode 100644 index 000000000..7d14eae83 --- /dev/null +++ b/dev/tests/test_panel_stage_b_hausman_covariance.py @@ -0,0 +1,73 @@ +"""Regression contract for Stage-B Hausman covariance degrees of freedom.""" + +from __future__ import annotations + +import numpy as np +from numpy.testing import assert_allclose + +from statgpu.panel import PanelOLS, RandomEffects + + +def _panel(seed=1250): + rng = np.random.default_rng(seed) + n_entities, n_times = 9, 5 + entity = np.repeat(np.arange(n_entities), n_times) + X = rng.normal(size=(entity.size, 2)) + alpha = np.repeat(np.linspace(-0.6, 0.7, n_entities), n_times) + y = 0.9 * X[:, 0] - 0.35 * X[:, 1] + alpha + rng.normal( + scale=0.2, size=entity.size + ) + return X, y, entity + + +def test_hausman_uses_standard_fe_covariance_without_changing_legacy_inference(): + X, y, entity = _panel() + fe = PanelOLS(entity_effects=True, cov_type="nonrobust").fit( + X, y, entity_ids=entity + ) + re = RandomEffects().fit(X, y, entity_ids=entity) + + raw_fe = np.asarray(fe._panel_cov_params_raw) + raw_re = np.asarray(re._panel_cov_params_raw) + diag_meta = fe.fit_statistics_.metadata["diagnostic_df"] + legacy_df = fe.fit_statistics_.metadata["legacy_df_resid"] + standard_df = diag_meta["df_resid"] + + # Stage A's historical FE inference denominator is intentionally retained. + assert legacy_df == fe.df_resid + assert standard_df == legacy_df - 1 + assert_allclose(fe.bse_ ** 2, np.diag(raw_fe), rtol=1e-12, atol=1e-14) + + # Classical Hausman, however, needs the full nuisance-effect model rank. + # Only the small diagnostic covariance copy is rescaled; public bse/CI above + # still come from the raw Stage-A covariance. + expected_fe_diagnostic = raw_fe * (legacy_df / standard_df) + assert_allclose( + fe._panel_cov_params, + expected_fe_diagnostic, + rtol=1e-12, + atol=1e-14, + ) + + # RandomEffects has no legacy FE nuisance-df mismatch, so its diagnostic + # covariance is exactly the inference covariance. + assert_allclose(re._panel_cov_params, raw_re, rtol=0, atol=0) + + # The Hausman entry point must consume the diagnostic matrices. Whether the + # finite-sample covariance difference is PSD is data-dependent; this check + # locks the exact matrix passed to the quadratic-form contract. + result = fe.hausman_test(re) + expected_difference = expected_fe_diagnostic - raw_re + eigvals = np.linalg.eigvalsh(0.5 * (expected_difference + expected_difference.T)) + assert_allclose( + result.metadata["minimum_eigenvalue"], + eigvals.min(), + rtol=1e-10, + atol=1e-12, + ) + assert_allclose( + result.metadata["maximum_eigenvalue"], + eigvals.max(), + rtol=1e-10, + atol=1e-12, + ) From e7a04214f177d9b18f5a500cbcbb2caee2fc96d8 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 11:14:11 +0800 Subject: [PATCH 026/165] ci: fold Panel Stage B into maintained Torch CPU gate --- .github/workflows/test.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index e496c907c..1eda6e332 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -183,6 +183,7 @@ jobs: python -m pytest \ dev/tests/test_logistic_cv_torch_dtype.py \ dev/tests/test_panel_stage_a_torch_cpu.py \ + dev/tests/test_panel_stage_b_torch_cpu.py \ -q --tb=short static-contracts: From 0b4e3252f2ab56a21ceb847b861459e61a722714 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 11:14:22 +0800 Subject: [PATCH 027/165] ci: remove redundant Panel Stage B Torch workflow --- .github/workflows/panel-stage-b-torch.yml | 39 ----------------------- 1 file changed, 39 deletions(-) delete mode 100644 .github/workflows/panel-stage-b-torch.yml diff --git a/.github/workflows/panel-stage-b-torch.yml b/.github/workflows/panel-stage-b-torch.yml deleted file mode 100644 index 40bbc199c..000000000 --- a/.github/workflows/panel-stage-b-torch.yml +++ /dev/null @@ -1,39 +0,0 @@ -name: Panel Stage B Torch CPU - -on: - push: - branches: [master] - pull_request: - branches: [master] - -permissions: - contents: read - -jobs: - panel-stage-b-torch-cpu: - runs-on: ubuntu-latest - timeout-minutes: 15 - steps: - - uses: actions/checkout@v4 - - uses: actions/setup-python@v5 - with: - python-version: '3.9' - - name: Install Torch 2.0 CPU regression environment - run: | - python -m pip install --upgrade pip - python -m pip install "numpy<2" pytest - python -m pip install "torch==2.0.1+cpu" --extra-index-url https://download.pytorch.org/whl/cpu - python -m pip install -e . - - name: Confirm Torch regression environment - run: | - python - <<'PY' - import torch - assert torch.__version__.startswith("2.0.1") - assert not torch.cuda.is_available() - print("torch", torch.__version__, "device=cpu") - PY - - name: Run Panel Stage B Torch CPU regressions - run: | - python -m pytest \ - dev/tests/test_panel_stage_b_torch_cpu.py \ - -q --tb=short From 73cc9141af4f09cc07f078d58e9bdd611859a808 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 11:15:35 +0800 Subject: [PATCH 028/165] test: add linearmodels 7.0 alignment gate for Panel Stage B --- dev/tests/test_panel_stage_b_linearmodels.py | 150 +++++++++++++++++++ 1 file changed, 150 insertions(+) create mode 100644 dev/tests/test_panel_stage_b_linearmodels.py diff --git a/dev/tests/test_panel_stage_b_linearmodels.py b/dev/tests/test_panel_stage_b_linearmodels.py new file mode 100644 index 000000000..880631c1b --- /dev/null +++ b/dev/tests/test_panel_stage_b_linearmodels.py @@ -0,0 +1,150 @@ +"""Executable external-definition alignment against linearmodels 7.0. + +This file is run in a dedicated CI job that installs linearmodels==7.0. It +compares only quantities whose estimator parameterizations are intentionally +aligned in Stage B. RandomEffects coefficients are excluded because statgpu's +existing Swamy-Arora path is a preserved model-specific contract. +""" + +from __future__ import annotations + +import numpy as np +import pandas as pd +from numpy.testing import assert_allclose + +from linearmodels.panel import ( + BetweenOLS as LMBetweenOLS, + FirstDifferenceOLS as LMFirstDifferenceOLS, + PanelOLS as LMPanelOLS, + PooledOLS as LMPooledOLS, +) + +from statgpu.panel import BetweenOLS, FirstDifferenceOLS, PanelOLS, PooledOLS + + +def _panel(seed=1260, *, unbalanced=False): + rng = np.random.default_rng(seed) + n_entities, n_times = 9, 6 + entity = np.repeat(np.arange(n_entities), n_times) + time = np.tile(np.arange(n_times), n_entities) + X = rng.normal(size=(entity.size, 2)) + alpha = np.repeat(np.linspace(-0.65, 0.75, n_entities), n_times) + tau = np.tile(np.linspace(-0.2, 0.25, n_times), n_entities) + y = 0.85 * X[:, 0] - 0.4 * X[:, 1] + alpha + tau + rng.normal( + scale=0.2, size=entity.size + ) + if unbalanced: + keep = np.ones(entity.size, dtype=bool) + keep[[1, 8, 17, 31, 44]] = False + X, y, entity, time = X[keep], y[keep], entity[keep], time[keep] + return X, y, entity, time + + +def _lm_data(X, y, entity, time, *, constant=False): + index = pd.MultiIndex.from_arrays([entity, time], names=["entity", "time"]) + y_series = pd.Series(y, index=index, name="y") + X_frame = pd.DataFrame(X, index=index, columns=["x1", "x2"]) + if constant: + X_frame.insert(0, "const", 1.0) + return y_series, X_frame + + +def _assert_r2(actual, expected): + assert_allclose(actual.rsquared_within, expected.rsquared_within, rtol=2e-10, atol=2e-11) + assert_allclose(actual.rsquared_between, expected.rsquared_between, rtol=2e-10, atol=2e-11) + assert_allclose(actual.rsquared_overall, expected.rsquared_overall, rtol=2e-10, atol=2e-11) + + +def _assert_model_f(actual, expected): + assert actual.f_statistic is not None + assert_allclose(actual.f_statistic, expected.f_statistic.stat, rtol=2e-9, atol=2e-11) + assert_allclose(actual.f_pvalue, expected.f_statistic.pval, rtol=2e-8, atol=1e-14) + assert actual.f_df == ( + float(expected.f_statistic.df), + float(expected.f_statistic.df_denom), + ) + + +def test_one_way_panelols_matches_linearmodels_parameter_r2_f_pooling_and_diagnostic_covariance(): + X, y, entity, time = _panel(unbalanced=True) + y_lm, X_lm = _lm_data(X, y, entity, time, constant=False) + lm = LMPanelOLS(y_lm, X_lm, entity_effects=True).fit( + cov_type="unadjusted", debiased=True + ) + sg = PanelOLS(entity_effects=True, cov_type="nonrobust").fit( + X, y, entity_ids=entity + ) + + assert_allclose(sg.coef_, lm.params.to_numpy(), rtol=2e-10, atol=2e-11) + _assert_r2(sg.fit_statistics_, lm) + _assert_model_f(sg.fit_statistics_, lm) + + pooled = sg.pooling_f_test() + assert pooled.applicable + assert_allclose(pooled.statistic, lm.f_pooled.stat, rtol=2e-9, atol=2e-11) + assert_allclose(pooled.pvalue, lm.f_pooled.pval, rtol=2e-8, atol=1e-14) + assert pooled.df == (float(lm.f_pooled.df), float(lm.f_pooled.df_denom)) + + # Stage-A public FE bse intentionally preserves its historical df. Stage-B + # Hausman uses a separate small covariance rescaled to the standard full + # nuisance-effect rank; this matrix should align with linearmodels. + assert_allclose( + sg._panel_cov_params, + lm.cov.to_numpy(), + rtol=5e-9, + atol=5e-11, + ) + + +def test_two_way_panelols_matches_linearmodels_standard_diagnostics(): + X, y, entity, time = _panel(seed=1261) + y_lm, X_lm = _lm_data(X, y, entity, time, constant=False) + lm = LMPanelOLS( + y_lm, + X_lm, + entity_effects=True, + time_effects=True, + ).fit(cov_type="unadjusted", debiased=True) + sg = PanelOLS( + entity_effects=True, + time_effects=True, + cov_type="nonrobust", + ).fit(X, y, entity_ids=entity, time_ids=time) + + assert_allclose(sg.coef_, lm.params.to_numpy(), rtol=2e-10, atol=2e-11) + _assert_r2(sg.fit_statistics_, lm) + _assert_model_f(sg.fit_statistics_, lm) + pooled = sg.pooling_f_test() + assert pooled.applicable + assert_allclose(pooled.statistic, lm.f_pooled.stat, rtol=2e-9, atol=2e-11) + assert_allclose(pooled.pvalue, lm.f_pooled.pval, rtol=2e-8, atol=1e-14) + assert pooled.df == (float(lm.f_pooled.df), float(lm.f_pooled.df_denom)) + assert_allclose(sg._panel_cov_params, lm.cov.to_numpy(), rtol=5e-9, atol=5e-11) + + +def test_pooled_between_and_first_difference_match_linearmodels_fit_statistics(): + X, y, entity, time = _panel(seed=1262, unbalanced=True) + + y_lm, X_lm_const = _lm_data(X, y, entity, time, constant=True) + lm_pool = LMPooledOLS(y_lm, X_lm_const).fit(cov_type="unadjusted", debiased=True) + sg_pool = PooledOLS().fit(X, y, entity_ids=entity) + assert_allclose(sg_pool.coef_, lm_pool.params.to_numpy(), rtol=2e-10, atol=2e-11) + _assert_r2(sg_pool.fit_statistics_, lm_pool) + _assert_model_f(sg_pool.fit_statistics_, lm_pool) + + lm_between = LMBetweenOLS(y_lm, X_lm_const).fit(cov_type="unadjusted", debiased=True) + sg_between = BetweenOLS().fit(X, y, entity_ids=entity) + assert_allclose(sg_between.coef_, lm_between.params.to_numpy(), rtol=2e-10, atol=2e-11) + _assert_r2(sg_between.fit_statistics_, lm_between) + _assert_model_f(sg_between.fit_statistics_, lm_between) + + y_lm_fd, X_lm_fd = _lm_data(X, y, entity, time, constant=False) + lm_fd = LMFirstDifferenceOLS(y_lm_fd, X_lm_fd).fit( + cov_type="unadjusted", debiased=True + ) + sg_fd = FirstDifferenceOLS().fit( + X, y, entity_ids=entity, time_ids=time + ) + assert_allclose(sg_fd.coef_, lm_fd.params.to_numpy(), rtol=2e-10, atol=2e-11) + _assert_r2(sg_fd.fit_statistics_, lm_fd) + _assert_model_f(sg_fd.fit_statistics_, lm_fd) From f69476be312a608b6778b668f44bd7d9a040ef11 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 11:16:20 +0800 Subject: [PATCH 029/165] ci: add linearmodels 7.0 Panel Stage B alignment gate --- .github/workflows/test.yml | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 1eda6e332..a0643ef4d 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -186,6 +186,28 @@ jobs: dev/tests/test_panel_stage_b_torch_cpu.py \ -q --tb=short + panel-stage-b-linearmodels: + runs-on: ubuntu-latest + timeout-minutes: 15 + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: '3.11' + - name: Install current external panel reference + run: | + python -m pip install --upgrade pip + python -m pip install -e . "linearmodels==7.0" + - name: Confirm linearmodels reference version + run: | + python - <<'PY' + import linearmodels + assert linearmodels.__version__ == "7.0" + print("linearmodels", linearmodels.__version__) + PY + - name: Run Panel Stage B external alignment + run: python -m pytest dev/tests/test_panel_stage_b_linearmodels.py -q --tb=short + static-contracts: runs-on: ubuntu-latest steps: From 4502f815749603dcf07b59031336c1d97c298d20 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 11:17:37 +0800 Subject: [PATCH 030/165] test: add physical GPU acceptance runner for Panel Stage B --- dev/benchmarks/validate_panel_stage_b_gpu.py | 447 +++++++++++++++++++ 1 file changed, 447 insertions(+) create mode 100644 dev/benchmarks/validate_panel_stage_b_gpu.py diff --git a/dev/benchmarks/validate_panel_stage_b_gpu.py b/dev/benchmarks/validate_panel_stage_b_gpu.py new file mode 100644 index 000000000..afc164dcf --- /dev/null +++ b/dev/benchmarks/validate_panel_stage_b_gpu.py @@ -0,0 +1,447 @@ +#!/usr/bin/env python3 +"""Physical CuPy/Torch acceptance for Panel Tier-1 Stage B (Issue #93). + +This is a correctness/backend-provenance gate, not a performance benchmark. +It validates the new parameter-based fit statistics and specification tests on +balanced and unbalanced panels against the NumPy implementation while proving +that requested CuPy/Torch CUDA backends actually execute. +""" + +from __future__ import annotations + +import argparse +import importlib.metadata +import json +import platform +import subprocess +from datetime import datetime, timezone +from pathlib import Path + +import numpy as np + +from statgpu.backends import _to_numpy +from statgpu.panel import ( + BetweenOLS, + FamaMacBeth, + FirstDifferenceOLS, + PanelOLS, + PooledOLS, + RandomEffects, +) + + +def _git_sha() -> str: + return subprocess.check_output(["git", "rev-parse", "HEAD"], text=True).strip() + + +def _git_status_porcelain() -> str: + return subprocess.check_output(["git", "status", "--porcelain"], text=True) + + +def _version(name: str): + try: + return importlib.metadata.version(name) + except importlib.metadata.PackageNotFoundError: + return None + + +def _dataset(seed: int, *, unbalanced: bool): + rng = np.random.default_rng(seed) + n_entities, n_times = 9, 6 + entity = np.repeat(np.arange(n_entities), n_times) + time = np.tile(np.arange(n_times), n_entities) + X = rng.normal(size=(entity.size, 2)) + entity_effect = np.repeat(np.linspace(-0.7, 0.8, n_entities), n_times) + time_effect = np.tile(np.linspace(-0.22, 0.27, n_times), n_entities) + y = ( + 0.9 * X[:, 0] + - 0.4 * X[:, 1] + + entity_effect + + 0.25 * time_effect + + rng.normal(scale=0.18, size=entity.size) + ) + if unbalanced: + keep = np.ones(entity.size, dtype=bool) + keep[[1, 8, 17, 31, 44]] = False + X, y, entity, time = X[keep], y[keep], entity[keep], time[keep] + return X.astype(np.float64), y.astype(np.float64), entity, time + + +def _to_backend_arrays(X, y, entity, time, backend): + if backend == "numpy": + return X, y, entity, time + if backend == "cupy": + import cupy as cp + + return ( + cp.asarray(X), + cp.asarray(y), + cp.asarray(entity, dtype=cp.int64), + cp.asarray(time, dtype=cp.int64), + ) + if backend == "torch": + import torch + + return ( + torch.as_tensor(X, dtype=torch.float64, device="cuda"), + torch.as_tensor(y, dtype=torch.float64, device="cuda"), + torch.as_tensor(entity, dtype=torch.int64, device="cuda"), + torch.as_tensor(time, dtype=torch.int64, device="cuda"), + ) + raise ValueError(backend) + + +def _device_arg(backend): + return {"numpy": "cpu", "cupy": "cuda", "torch": "torch"}[backend] + + +def _backend_name(model): + if isinstance(model, FamaMacBeth): + return model._backend_name + return model._get_backend(backend="auto").name + + +def _array(value): + return np.asarray(_to_numpy(value), dtype=np.float64) + + +def _fit_stats(model): + result = model.fit_statistics_ + payload = { + "rsquared_within": result.rsquared_within, + "rsquared_between": result.rsquared_between, + "rsquared_overall": result.rsquared_overall, + "rsquared_adj": result.rsquared_adj, + "f_statistic": result.f_statistic, + "f_pvalue": result.f_pvalue, + "f_df": None if result.f_df is None else tuple(float(x) for x in result.f_df), + } + return payload + + +def _test_result(result): + return { + "applicable": bool(result.applicable), + "reason": result.reason, + "statistic": result.statistic, + "pvalue": result.pvalue, + "df": result.df, + "distribution": result.distribution, + } + + +def _model_snapshot(model): + payload = { + "coef": _array(model.coef_).ravel(), + "fit_statistics": _fit_stats(model), + } + covariance = getattr(model, "_panel_cov_params", None) + if covariance is not None: + payload["diagnostic_covariance"] = _array(covariance) + if hasattr(model, "pooling_f_test") and isinstance(model, PanelOLS): + payload["pooling_f"] = _test_result(model.pooling_f_test()) + if hasattr(model, "breusch_pagan_lm_test") and isinstance(model, PooledOLS): + payload["bp_lm"] = _test_result(model.breusch_pagan_lm_test()) + return payload + + +def _fit_cases(X, y, entity, time, backend, *, unbalanced): + Xb, yb, eb, tb = _to_backend_arrays(X, y, entity, time, backend) + device = _device_arg(backend) + suffix = "unbalanced" if unbalanced else "balanced" + cases = {} + + pooled = PooledOLS(device=device).fit(Xb, yb, entity_ids=eb) + cases[f"pooled_{suffix}"] = pooled + + scrambled_time_np = (3 * time + 2 * entity + 1) % 11 + if backend == "numpy": + scrambled_time = scrambled_time_np + elif backend == "cupy": + import cupy as cp + + scrambled_time = cp.asarray(scrambled_time_np, dtype=cp.int64) + else: + import torch + + scrambled_time = torch.as_tensor( + scrambled_time_np, dtype=torch.int64, device="cuda" + ) + pooled_hac = PooledOLS(cov_type="hac", bandwidth=2, device=device).fit( + Xb, + yb, + time_index=scrambled_time, + entity_ids=eb, + ) + cases[f"pooled_hac_unsorted_{suffix}"] = pooled_hac + + between = BetweenOLS(cov_type="robust", device=device).fit( + Xb, yb, entity_ids=eb + ) + cases[f"between_{suffix}"] = between + + first_diff = FirstDifferenceOLS(cov_type="robust", device=device).fit( + Xb, yb, entity_ids=eb, time_ids=tb + ) + cases[f"first_difference_{suffix}"] = first_diff + + fe = PanelOLS(entity_effects=True, cov_type="nonrobust", device=device).fit( + Xb, yb, entity_ids=eb + ) + cases[f"panel_entity_{suffix}"] = fe + + re = RandomEffects(device=device).fit(Xb, yb, entity_ids=eb) + cases[f"random_effects_{suffix}"] = re + + fmb = FamaMacBeth(cov_type="newey-west", bandwidth=2, device=device).fit( + Xb, + yb, + time_ids=tb, + entity_ids=eb, + ) + cases[f"fama_macbeth_{suffix}"] = fmb + + diagnostics = { + f"hausman_{suffix}": _test_result(fe.hausman_test(re)), + } + + if not unbalanced: + two_way = PanelOLS( + entity_effects=True, + time_effects=True, + cov_type="nonrobust", + device=device, + ).fit(Xb, yb, entity_ids=eb, time_ids=tb) + cases["panel_two_way_balanced"] = two_way + + return cases, diagnostics + + +def _scalar_diff(actual, expected, *, rtol, atol, label): + if expected is None: + if actual is not None: + raise AssertionError(f"{label}: expected None, got {actual}") + return 0.0 + np.testing.assert_allclose(actual, expected, rtol=rtol, atol=atol, err_msg=label) + return float(abs(float(actual) - float(expected))) + + +def _compare_test_result(reference, candidate, *, rtol, atol, label): + if candidate["applicable"] != reference["applicable"]: + raise AssertionError( + f"{label}: applicability {candidate['applicable']} != {reference['applicable']}" + ) + if candidate["distribution"] != reference["distribution"]: + raise AssertionError(f"{label}: distribution mismatch") + if candidate["reason"] != reference["reason"]: + raise AssertionError( + f"{label}: reason {candidate['reason']!r} != {reference['reason']!r}" + ) + differences = {} + for field in ("statistic", "pvalue"): + differences[field] = _scalar_diff( + candidate[field], + reference[field], + rtol=rtol, + atol=atol, + label=f"{label}.{field}", + ) + ref_df = reference["df"] + cand_df = candidate["df"] + if ref_df is None: + if cand_df is not None: + raise AssertionError(f"{label}.df expected None") + elif isinstance(ref_df, (tuple, list)): + np.testing.assert_allclose(cand_df, ref_df, rtol=0, atol=0) + else: + np.testing.assert_allclose(cand_df, ref_df, rtol=0, atol=0) + return differences + + +def _compare_model(reference, candidate, *, rtol, atol, label): + differences = {} + np.testing.assert_allclose( + candidate["coef"], reference["coef"], rtol=rtol, atol=atol, + err_msg=f"{label}.coef", + ) + differences["coef"] = float( + np.max(np.abs(candidate["coef"] - reference["coef"])) + ) + + for field, expected in reference["fit_statistics"].items(): + actual = candidate["fit_statistics"][field] + if field == "f_df": + if expected is None: + if actual is not None: + raise AssertionError(f"{label}.fit_statistics.f_df expected None") + else: + np.testing.assert_allclose(actual, expected, rtol=0, atol=0) + continue + differences[f"fit_statistics.{field}"] = _scalar_diff( + actual, + expected, + rtol=rtol, + atol=atol, + label=f"{label}.fit_statistics.{field}", + ) + + if "diagnostic_covariance" in reference: + np.testing.assert_allclose( + candidate["diagnostic_covariance"], + reference["diagnostic_covariance"], + rtol=rtol, + atol=atol, + err_msg=f"{label}.diagnostic_covariance", + ) + differences["diagnostic_covariance"] = float( + np.max( + np.abs( + candidate["diagnostic_covariance"] + - reference["diagnostic_covariance"] + ) + ) + ) + + for test_name in ("pooling_f", "bp_lm"): + if test_name in reference: + nested = _compare_test_result( + reference[test_name], + candidate[test_name], + rtol=rtol, + atol=atol, + label=f"{label}.{test_name}", + ) + differences.update( + {f"{test_name}.{name}": value for name, value in nested.items()} + ) + return differences + + +def _environment(backends): + gpu = None + if "torch" in backends: + import torch + + if not torch.cuda.is_available(): + raise RuntimeError("Torch backend requested but CUDA is unavailable") + gpu = torch.cuda.get_device_name(0) + elif "cupy" in backends: + import cupy as cp + + if cp.cuda.runtime.getDeviceCount() < 1: + raise RuntimeError("CuPy backend requested but CUDA is unavailable") + props = cp.cuda.runtime.getDeviceProperties(0) + gpu = props["name"].decode() if isinstance(props["name"], bytes) else props["name"] + return { + "python": platform.python_version(), + "platform": platform.platform(), + "gpu": gpu, + "packages": { + name: _version(name) + for name in ("statgpu", "numpy", "scipy", "cupy", "torch") + }, + } + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--out", type=Path, required=True) + parser.add_argument("--backends", default="cupy,torch") + parser.add_argument("--expected-sha", required=True) + parser.add_argument("--rtol", type=float, default=5e-6) + parser.add_argument("--atol", type=float, default=5e-7) + args = parser.parse_args() + + backends = [value.strip() for value in args.backends.split(",") if value.strip()] + if not backends or any(value not in {"cupy", "torch"} for value in backends): + raise ValueError("--backends must contain cupy and/or torch") + + sha = _git_sha() + if sha != args.expected_sha: + raise RuntimeError(f"wrong source head: {sha} != {args.expected_sha}") + dirty = _git_status_porcelain() + if dirty.strip(): + raise RuntimeError( + "physical acceptance requires a clean working tree; uncommitted changes:\n" + + dirty + ) + + datasets = { + "balanced": _dataset(20260808, unbalanced=False), + "unbalanced": _dataset(20260809, unbalanced=True), + } + reference_models = {} + reference_diagnostics = {} + for name, (X, y, entity, time) in datasets.items(): + models, diagnostics = _fit_cases( + X, y, entity, time, "numpy", unbalanced=(name == "unbalanced") + ) + reference_models.update( + {case: _model_snapshot(model) for case, model in models.items()} + ) + reference_diagnostics.update(diagnostics) + + results = {} + for backend in backends: + backend_payload = {"models": {}, "diagnostics": {}} + for name, (X, y, entity, time) in datasets.items(): + models, diagnostics = _fit_cases( + X, y, entity, time, backend, unbalanced=(name == "unbalanced") + ) + for case, model in models.items(): + actual_backend = _backend_name(model) + if actual_backend != backend: + raise AssertionError( + f"{case}: requested {backend}, executed {actual_backend}" + ) + snapshot = _model_snapshot(model) + differences = _compare_model( + reference_models[case], + snapshot, + rtol=args.rtol, + atol=args.atol, + label=case, + ) + backend_payload["models"][case] = { + "status": "success", + "executed_backend": actual_backend, + "max_abs_differences": differences, + } + for case, result in diagnostics.items(): + differences = _compare_test_result( + reference_diagnostics[case], + result, + rtol=args.rtol, + atol=args.atol, + label=case, + ) + backend_payload["diagnostics"][case] = { + "status": "success", + "max_abs_differences": differences, + "applicable": result["applicable"], + "reason": result["reason"], + } + results[backend] = backend_payload + + payload = { + "schema_version": 1, + "generated_at": datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"), + "git_sha": sha, + "working_tree_clean": True, + "status": "success", + "environment": _environment(backends), + "tolerances": {"rtol": args.rtol, "atol": args.atol}, + "datasets": { + name: {"nobs": int(len(values[1]))} + for name, values in datasets.items() + }, + "backends": results, + } + args.out.parent.mkdir(parents=True, exist_ok=True) + args.out.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8") + print(json.dumps(payload, indent=2)) + print(f"PASS — Panel Stage B physical GPU validation: {args.out}") + + +if __name__ == "__main__": + main() From e27e40621210d8770cf82acd209a852d3a8ba4c2 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 11:19:22 +0800 Subject: [PATCH 031/165] ci: install pytest in Panel Stage B external alignment job --- .github/workflows/test.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index a0643ef4d..322fc0111 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -197,7 +197,7 @@ jobs: - name: Install current external panel reference run: | python -m pip install --upgrade pip - python -m pip install -e . "linearmodels==7.0" + python -m pip install -e . "linearmodels==7.0" pytest - name: Confirm linearmodels reference version run: | python - <<'PY' From 797482f6ba71c7674ee4224e66d76087b95c69b1 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 11:20:03 +0800 Subject: [PATCH 032/165] test: isolate optional linearmodels dependency to external gate --- dev/tests/test_panel_stage_b_linearmodels.py | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/dev/tests/test_panel_stage_b_linearmodels.py b/dev/tests/test_panel_stage_b_linearmodels.py index 880631c1b..575c32297 100644 --- a/dev/tests/test_panel_stage_b_linearmodels.py +++ b/dev/tests/test_panel_stage_b_linearmodels.py @@ -1,6 +1,6 @@ """Executable external-definition alignment against linearmodels 7.0. -This file is run in a dedicated CI job that installs linearmodels==7.0. It +This file is run in a dedicated CI job that installs linearmodels==7.0. It compares only quantities whose estimator parameterizations are intentionally aligned in Stage B. RandomEffects coefficients are excluded because statgpu's existing Swamy-Arora path is a preserved model-specific contract. @@ -10,8 +10,14 @@ import numpy as np import pandas as pd +import pytest from numpy.testing import assert_allclose +pytest.importorskip( + "linearmodels", + reason="linearmodels is an external Stage-B definition gate, not a base dependency", +) + from linearmodels.panel import ( BetweenOLS as LMBetweenOLS, FirstDifferenceOLS as LMFirstDifferenceOLS, From 30c4f618932c3367c54bc31d1b9d2f9eaf2a4176 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 11:22:16 +0800 Subject: [PATCH 033/165] docs: document Panel Stage B diagnostics and fit statistics --- docs/en/models/panel.md | 241 +++++++++++++++++++++++++++++++++------- 1 file changed, 201 insertions(+), 40 deletions(-) diff --git a/docs/en/models/panel.md b/docs/en/models/panel.md index 9b6b3ca80..f7767ece5 100644 --- a/docs/en/models/panel.md +++ b/docs/en/models/panel.md @@ -1,7 +1,7 @@ # Panel Models > Language: English -> Last updated: 2026-07-24 +> Last updated: 2026-08-08 > This page: Model documentation > Switch: [Chinese](../../cn/models/panel.md) @@ -10,7 +10,7 @@ The `statgpu.panel` module provides six panel-data estimators: - `PanelOLS`: entity and/or time fixed effects; -- `RandomEffects`: feasible GLS random effects; +- `RandomEffects`: Swamy-Arora feasible GLS random effects; - `PooledOLS`: stacked OLS without demeaning; - `BetweenOLS`: regression on entity means; - `FirstDifferenceOLS`: within-entity first differences; @@ -18,6 +18,8 @@ The `statgpu.panel` module provides six panel-data estimators: Array-input numerical paths support NumPy, CuPy CUDA, and Torch CUDA. Formula construction and categorical entity/time/cluster labels are intentional CPU metadata boundaries; compact aligned codes are transferred to the selected numerical backend. Explicit GPU devices do not silently fall back to CPU. +Stage B of the Tier-1 panel roadmap adds parameter-based fit statistics and three structured specification tests without changing the Stage-A coefficient, prediction, covariance-normalization, or legacy inference contracts. + ## Paths ```python @@ -28,22 +30,29 @@ from statgpu.panel import ( BetweenOLS, FirstDifferenceOLS, FamaMacBeth, + PanelTestResult, + PanelFitStatistics, + hausman_test, + pooling_f_test, + breusch_pagan_lm_test, clustered_covariance, two_way_clustered_covariance, hac_covariance, ) ``` +The diagnostic result classes and functions are also exported from top-level `statgpu`. + ## Model Summary -| Model | Transformation | Main inference choices | -|---|---|---| -| `PanelOLS` | Entity/time within transformation | nonrobust, HC1 robust, clustered | -| `RandomEffects` | Swamy-Arora feasible GLS | nonrobust | -| `PooledOLS` | Stacked OLS | nonrobust, robust, clustered, HAC | -| `BetweenOLS` | Entity means | nonrobust, robust, clustered | -| `FirstDifferenceOLS` | Within-entity first differences | nonrobust, robust | -| `FamaMacBeth` | Cross-sectional regressions by period | nonrobust, Newey-West | +| Model | Transformation | Main inference choices | Stage-B fit statistics | +|---|---|---|---| +| `PanelOLS` | Entity/time within transformation | nonrobust, HC1 robust, clustered | within/between/overall R², adjusted R², classical model F, pooling F | +| `RandomEffects` | Swamy-Arora feasible GLS | nonrobust | within/between/overall R², adjusted R², classical model F, Hausman input | +| `PooledOLS` | Stacked OLS | nonrobust, robust, clustered, HAC | overall R² always; within/between R² and BP-LM when `entity_ids` is supplied; adjusted R² and classical model F | +| `BetweenOLS` | Entity means | nonrobust, robust | within/between/overall R², adjusted R², classical model F | +| `FirstDifferenceOLS` | Within-entity first differences | nonrobust, robust | within/between/overall R², adjusted R² on the differenced fit space, classical model F | +| `FamaMacBeth` | Cross-sectional regressions by period | nonrobust, Newey-West | parameter-based within/between/overall R²; no residual-OLS adjusted R² or model F | ## Core Estimating Equations @@ -55,7 +64,7 @@ y_{it}^{\mathrm{within}} = y_{it} - \bar y_{i\cdot}, X_{it}^{\mathrm{within}} = X_{it} - \bar X_{i\cdot}. $$ -With entity and time effects, the two-way transformation adds back the grand mean. +With entity and time effects, the two-way transformation also removes time means and adds back the grand mean. `PooledOLS` fits @@ -65,19 +74,21 @@ $$ where \(X^+\) denotes the inverse or Moore-Penrose pseudoinverse as required. `BetweenOLS` applies OLS to entity means, `FirstDifferenceOLS` applies OLS to Δ\(X\) and Δ\(y\), and `FamaMacBeth` averages period-specific coefficient vectors. -## Covariance and Inference +## Covariance and Existing Inference | `cov_type` | Behavior | |---|---| | `"nonrobust"` | Classical OLS covariance and t-based inference | | `"robust"` | HC1 sandwich covariance and asymptotic normal inference | -| `"clustered"` | One-way or two-way cluster-robust covariance | +| `"clustered"` | Cluster-robust covariance where supported by the estimator | | `"hac"` | Bartlett/Newey-West HAC for `PooledOLS` | | `"newey-west"` | HAC applied to the `FamaMacBeth` coefficient path | +Stage B does not change existing `bse_`, `tvalues_`, `pvalues_`, `conf_int_`, or estimator-specific covariance definitions. RandomEffects robust covariance, HC0/HC2/HC3, Driscoll-Kraay, and expanded cluster corrections remain later Stage-C work. + ### PooledOLS HAC ordering -For `PooledOLS(cov_type="hac")`, pass `time_index=` to `fit`. The implementation validates the side array and uses a stable time ordering while keeping all numerical arrays aligned. Consequently, a row permutation with unchanged time labels produces the same HAC covariance, up to numerical tolerance. +For `PooledOLS(cov_type="hac")`, pass `time_index=` to `fit`. The implementation validates the side array and uses a stable time ordering while keeping X, y, and Stage-B entity diagnostic metadata under the identical permutation. Consequently, BP-LM and parameter-based R² cannot accidentally group residuals using pre-sort entity metadata. ### Rank-deficient PooledOLS @@ -86,9 +97,149 @@ A rank-deficient design separates fitted-space validity from coefficient-space i - fitting, prediction, residuals, RSS, rank, and fitted-space comparisons remain valid; - `df_resid` is computed as `nobs - rank(X)`, not `nobs - n_columns`; - individual coefficients are not unique under exact collinearity; -- coefficient-level covariance, BSE, test statistics, p-values, and confidence intervals are therefore non-identifiable and should be reported as `NOT_COMPARABLE`, not as a runtime error or a successful unique inference result. +- coefficient-level covariance, BSE, test statistics, p-values, and confidence intervals are therefore non-identifiable and should not be interpreted as unique coefficient inference. + +Stage-B model-F restrictions use effective numerical rank rather than blindly using the raw column count. + +## Standardized `fit_statistics_` + +Supported fits expose a structured `PanelFitStatistics` object: + +```python +stats = model.fit_statistics_ + +stats.rsquared_within +stats.rsquared_between +stats.rsquared_overall +stats.rsquared_adj +stats.f_statistic +stats.f_pvalue +stats.f_df +stats.metadata +``` + +### Parameter-based R² + +The within/between/overall R² family follows the parameter-based convention used by `linearmodels`: each statistic evaluates the fitted coefficient vector rather than squaring a fitted-value correlation. + +For coefficient vector \(\hat\beta\): + +- **overall R²** evaluates \(y-X\hat\beta\) on the level panel; +- **between R²** evaluates entity means \(\bar y_i-\bar X_i\hat\beta\); +- **within R²** evaluates entity-demeaned \(y\) and \(X\). + +Overall and between total sums of squares are centered only when the actual level regressor design contains an identified constant. Fixed effects by themselves do not change this centering rule. A zero total sum of squares is reported as `0.0` in the standardized Stage-B field and marked in `metadata["degenerate_total_ss"]`. + +### Legacy `PanelOLS.rsquared_within` + +`PanelOLS.rsquared_within` is retained exactly for Stage-A compatibility. In a two-way FE model it describes the historical full entity+time transformed fit and can differ from the standardized entity-within `fit_statistics_.rsquared_within`. Stage B does not silently overwrite the legacy attribute; the compatibility value is recorded in fit-statistics metadata. + +### Adjusted R² and diagnostic degrees of freedom + +For new standardized diagnostics, `PanelOLS` uses the rank of the complete fixed-effect nuisance space. Current `PanelOLS` does not retain an exogenous intercept, so the standard nuisance-effect rank is: + +- entity effects only: \(N\); +- time effects only: \(T\); +- entity and time effects: \(N+T-1\). + +If \(r_X\) is the numerical rank of the transformed slope design, Stage B uses + +$$ +\mathrm{df}_{\mathrm{resid,diag}} += n-r_X-r_{\mathrm{effects}}, +$$ + +and + +$$ +\mathrm{df}_{\mathrm{total,diag}} += n-r_{\mathrm{effects}} +$$ + +for the standardized FE model F and adjusted R². + +This is intentionally separate from the historical public `PanelOLS.df_resid`, which remains unchanged because existing covariance, t statistics, p-values, confidence intervals, and summaries depend on that compatibility convention. Hausman uses a diagnostic-only small FE covariance matrix rescaled to the standard nuisance-rank denominator; the public Stage-A BSE/CI remain unchanged. + +### Classical model F + +For OLS-style panel estimators, Stage B reports the classical homoskedastic joint-slope F statistic on the estimator's primary fit space: + +$$ +F= +\frac{(RSS_R-RSS_U)/q} + {RSS_U/\mathrm{df}_{\mathrm{resid}}}, +$$ + +where \(q\) is the effective restriction rank. A robust or clustered covariance choice does not silently convert this field into a robust Wald test. -The PR79 validation pipeline preserves prediction/RSS/rank contracts for rank-deficient cases while excluding non-identifiable coefficient-space comparisons. +`FamaMacBeth` does not receive a residual-OLS model F or adjusted R². Its covariance is based on the time series of cross-sectional coefficient estimates, and Stage B does not relabel that beta-series inference as residual OLS. + +## Specification Tests + +All specification tests return `PanelTestResult`. Econometrically inapplicable cases are structured results with `applicable=False` and a reason; malformed API calls still raise normal programming errors. + +### Pooling F test + +For a fitted `PanelOLS` with at least one effect: + +```python +result = fe.pooling_f_test() +# or +result = pooling_f_test(fe) +``` + +The classical poolability null is that all included fixed effects are jointly zero. The statistic compares the effect model against a nested pooled regression on the exact aligned estimation sample. + +When the FE level design has no explicit constant, the pooled null projects both y and X off the common constant before fitting the slopes. This prevents the common mean from being counted as a tested fixed effect. The numerator and denominator degrees of freedom are derived from effective nested-model ranks, not hard-coded effect counts. + +The test is classical/homoskedastic even when the fitted FE object uses a robust or clustered covariance for coefficient inference. + +### Breusch-Pagan LM for entity random effects + +Supply `entity_ids` to `PooledOLS.fit()`: + +```python +pooled = PooledOLS().fit(X, y, entity_ids=entity_ids) +result = pooled.breusch_pagan_lm_test() +# or +result = breusch_pagan_lm_test(pooled) +``` + +This is the **panel error-components Breusch-Pagan LM test**, not the cross-sectional heteroskedasticity Breusch-Pagan test. Stage B implements the one-way entity version, including the Baltagi-Li incomplete/unbalanced-panel formula used by `plm::plmtest(type="bp", effect="individual")`. + +The null is zero entity random-effect variance. At least two entities, positive pooled RSS, and at least one repeated observation within an entity are required. Without `entity_ids`, the result is structured as inapplicable rather than guessed from row order. + +### Classical Hausman FE versus RE + +```python +fe = PanelOLS(entity_effects=True, cov_type="nonrobust").fit( + X, y, entity_ids=entity_ids +) +re = RandomEffects().fit(X, y, entity_ids=entity_ids) + +result = fe.hausman_test(re) +# or +result = hausman_test(fe, re) +``` + +Stage B implements the original quadratic-form one-way entity FE-versus-RE Hausman test: + +$$ +H=(\hat\beta_{FE}-\hat\beta_{RE})^\top + (V_{FE}-V_{RE})^{-1} + (\hat\beta_{FE}-\hat\beta_{RE}). +$$ + +Applicability rules are explicit: + +- FE must be one-way entity effects only; +- the FE coefficient covariance must be classical/nonrobust; +- FE and RE must be fitted to the same aligned X/y/entity sample and common slope design; +- row/sample compatibility is checked using compact backend-native numerical fingerprints, not just matching shapes; +- intercepts are excluded from the comparison; +- a materially indefinite covariance difference is reported as inapplicable instead of being eigenvalue-clipped into a statistic. + +If the covariance difference is positive semidefinite but rank-deficient, statgpu provides a documented generalized-inverse extension: the test uses the identified range and chi-square degrees of freedom equal to the numerical rank, but only when the coefficient difference lies in that range. Metadata records `used_pinv=True` and labels this as the `singular PSD generalized-inverse Hausman` extension. Robust auxiliary-regression Hausman is not part of Stage B. ## Parameters and Fit Signatures @@ -104,9 +255,11 @@ PanelOLS( ``` ```python -model.fit(y, X, entity_ids=entity_ids, time_ids=time_ids, cluster=cluster) +model.fit(X, y, entity_ids=entity_ids, time_ids=time_ids, cluster=cluster) ``` +Formula input can also request effects through the existing pipe syntax, for example `"y ~ x1 + x2 | entity"`. Formula row filtering aligns side arrays to the retained estimation sample. + ### `PooledOLS` ```python @@ -120,10 +273,16 @@ PooledOLS( ``` ```python -model.fit(X, y, cluster=None, time_index=None) +model.fit( + X, + y, + cluster=None, + time_index=None, + entity_ids=None, +) ``` -`cluster` is required for clustered inference. `time_index` is strongly recommended for HAC inference and is used to define stable temporal ordering. +`cluster` is required for clustered inference. `time_index` defines stable temporal ordering for HAC. `entity_ids` is optional and does not change coefficients; it enables standardized within/between R² and the panel BP-LM diagnostic. ### Other models @@ -140,11 +299,13 @@ FamaMacBeth( ) ``` -## CPU and GPU Examples +`FamaMacBeth.fit(..., entity_ids=None)` accepts optional entity IDs only for Stage-B within/between R². The beta-series estimation and covariance path are unchanged. + +## CPU and GPU Example ```python import numpy as np -from statgpu.panel import PanelOLS, PooledOLS, FamaMacBeth +from statgpu.panel import PanelOLS, PooledOLS, RandomEffects n_entities, n_times = 50, 10 n = n_entities * n_times @@ -153,20 +314,20 @@ time_ids = np.tile(np.arange(n_times), n_entities) X = np.random.default_rng(0).normal(size=(n, 3)) y = X @ np.array([1.0, -0.5, 0.3]) + np.random.default_rng(1).normal(size=n) * 0.1 -# Fixed effects on CPU. -fe = PanelOLS(entity_effects=True, cov_type="robust", device="cpu") -fe.fit(y, X, entity_ids=entity_ids) +fe = PanelOLS(entity_effects=True, device="cpu").fit( + X, y, entity_ids=entity_ids +) +print(fe.fit_statistics_.rsquared_within) +print(fe.pooling_f_test()) -# HAC PooledOLS with explicit time ordering. -pooled_hac = PooledOLS(cov_type="hac", device="cpu") -pooled_hac.fit(X, y, time_index=time_ids) +pooled = PooledOLS(device="cpu").fit(X, y, entity_ids=entity_ids) +print(pooled.breusch_pagan_lm_test()) -# Fama-MacBeth on CuPy CUDA; metadata labels may remain on CPU. -fm = FamaMacBeth(cov_type="newey-west", device="cuda") -fm.fit(X, y, time_ids=time_ids) +re = RandomEffects(device="cpu").fit(X, y, entity_ids=entity_ids) +print(fe.hausman_test(re)) ``` -For Torch CUDA, pass CUDA tensors for numerical arrays and use `device="torch"`. Public prediction methods preserve the estimator backend for array inputs. +For CuPy CUDA use `device="cuda"`; for Torch CUDA use CUDA tensors and `device="torch"`. Stage-B sufficient-statistic accumulation follows the selected numerical backend. Only compact metadata, final scalars, and small covariance matrices cross the CPU metadata boundary. ## Outputs @@ -174,28 +335,28 @@ Common fitted attributes include: - `coef_`; - `bse_`, `tvalues_`, `pvalues_`, `conf_int_` when coefficient-space inference is identifiable; -- `rsquared` or `rsquared_within` as applicable; +- legacy `rsquared` or `rsquared_within` where historically exposed; +- standardized `fit_statistics_`; - `nobs`, `df_resid`, and effective rank where exposed; - `betas_`, `cov_params_`, and `n_periods` for `FamaMacBeth`. -For an exactly rank-deficient `PooledOLS` design, downstream consumers must not interpret coefficient-level inference as uniquely identified. +`PanelTestResult` contains `statistic`, `pvalue`, `distribution`, `df`, `null`, `alternative`, `applicable`, `reason`, and `metadata`. ## Formula and Metadata Boundaries -Formula evaluation may drop rows with missing values. Entity, time, cluster, and other side arrays are aligned to the retained rows. String and categorical labels are factorized on CPU; the numerical transformations and regression calculations remain on the selected backend. +Formula evaluation may drop rows with missing values. Entity, time, cluster, and other side arrays are aligned to the retained rows. String and categorical labels are factorized on CPU; numerical transforms and sufficient-statistic calculations remain on the selected backend. Hausman stores only compact sample/design fingerprints and a small covariance matrix rather than a second CPU copy of the full design. ## Validation -PR #79 validated maintained panel behavior across NumPy, CuPy CUDA, and Torch CUDA. The final maintained physical-GPU suite passed **33/33** checks on a Tesla P100, including backend-preserving `PooledOLS.predict()` and the rank-deficient `NOT_COMPARABLE` contract. GitHub Actions also passed the Python 3.9–3.12 regression matrix and full CPU suite on the exact head. - -See: +Stage A / PR #119 established the shared panel framework and passed exact-head physical validation on Tesla P100 across 10 CuPy and 10 Torch cases. -- `dev/reviews/pr79_physical_gpu_validation.md`; -- `dev/tests/test_pr79_physical_gpu.py`; -- Issue #83 for cleanup of ignored legacy GPU diagnostic scripts. +Stage B adds maintained analytic and fitted-model regression tests, formula/missing-row alignment tests, Python 3.9 + Torch 2.0 CPU parity coverage, and an executable `linearmodels==7.0` external-definition gate. Final promotion also requires `dev/benchmarks/validate_panel_stage_b_gpu.py` to pass on an exact clean commit for both CuPy and Torch CUDA; this runner is a correctness/provenance gate rather than a performance benchmark. ## References +- Hausman, J. A. (1978). Specification tests in econometrics. +- Breusch, T. S., & Pagan, A. R. (1980). The Lagrange multiplier test and its applications to model specification in econometrics. +- Baltagi, B. H., & Li, Q. (1990). A Lagrange multiplier test for the error components model with incomplete panels. - White, H. (1980). A heteroskedasticity-consistent covariance matrix estimator. - Newey, W. K., & West, K. D. (1987). A simple, positive semi-definite, heteroskedasticity and autocorrelation consistent covariance matrix. - Fama, E. F., & MacBeth, J. D. (1973). Risk, return, and equilibrium. From 086a1a5f56799c92b6b5c3845b939ce1f7073f58 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 13:10:01 +0800 Subject: [PATCH 034/165] test: isolate FirstDifference external alignment from internal panel gaps --- dev/tests/test_panel_stage_b_linearmodels.py | 83 ++++++++++++++++---- 1 file changed, 68 insertions(+), 15 deletions(-) diff --git a/dev/tests/test_panel_stage_b_linearmodels.py b/dev/tests/test_panel_stage_b_linearmodels.py index 575c32297..e1aa7af00 100644 --- a/dev/tests/test_panel_stage_b_linearmodels.py +++ b/dev/tests/test_panel_stage_b_linearmodels.py @@ -1,9 +1,10 @@ """Executable external-definition alignment against linearmodels 7.0. This file is run in a dedicated CI job that installs linearmodels==7.0. It -compares only quantities whose estimator parameterizations are intentionally -aligned in Stage B. RandomEffects coefficients are excluded because statgpu's -existing Swamy-Arora path is a preserved model-specific contract. +compares only quantities whose estimator parameterizations and transformed +samples are intentionally aligned in Stage B. RandomEffects coefficients are +excluded because statgpu's existing Swamy-Arora path is a preserved +model-specific contract. """ from __future__ import annotations @@ -40,12 +41,30 @@ def _panel(seed=1260, *, unbalanced=False): scale=0.2, size=entity.size ) if unbalanced: + # Deliberately contains internal gaps. This is appropriate for pooled, + # between and FE comparisons, but it is not used for FirstDifference + # because Stage A preserves statgpu's adjacent-observed-row differencing + # contract while linearmodels constructs first differences on its panel + # time grid. Stage B must not use an external gate to change that + # estimator transformation implicitly. keep = np.ones(entity.size, dtype=bool) keep[[1, 8, 17, 31, 44]] = False X, y, entity, time = X[keep], y[keep], entity[keep], time[keep] return X, y, entity, time +def _gap_free_unbalanced_panel(seed=1263): + """Return an unbalanced panel with contiguous time support per entity.""" + X, y, entity, time = _panel(seed=seed, unbalanced=False) + keep = np.ones(len(y), dtype=bool) + # Remove only trailing observations from selected entities, so every + # retained entity still has contiguous time indices starting at zero. + keep[(entity == 1) & (time >= 5)] = False + keep[(entity == 3) & (time >= 4)] = False + keep[(entity == 7) & (time >= 3)] = False + return X[keep], y[keep], entity[keep], time[keep] + + def _lm_data(X, y, entity, time, *, constant=False): index = pd.MultiIndex.from_arrays([entity, time], names=["entity", "time"]) y_series = pd.Series(y, index=index, name="y") @@ -56,15 +75,40 @@ def _lm_data(X, y, entity, time, *, constant=False): def _assert_r2(actual, expected): - assert_allclose(actual.rsquared_within, expected.rsquared_within, rtol=2e-10, atol=2e-11) - assert_allclose(actual.rsquared_between, expected.rsquared_between, rtol=2e-10, atol=2e-11) - assert_allclose(actual.rsquared_overall, expected.rsquared_overall, rtol=2e-10, atol=2e-11) + assert_allclose( + actual.rsquared_within, + expected.rsquared_within, + rtol=2e-10, + atol=2e-11, + ) + assert_allclose( + actual.rsquared_between, + expected.rsquared_between, + rtol=2e-10, + atol=2e-11, + ) + assert_allclose( + actual.rsquared_overall, + expected.rsquared_overall, + rtol=2e-10, + atol=2e-11, + ) def _assert_model_f(actual, expected): assert actual.f_statistic is not None - assert_allclose(actual.f_statistic, expected.f_statistic.stat, rtol=2e-9, atol=2e-11) - assert_allclose(actual.f_pvalue, expected.f_statistic.pval, rtol=2e-8, atol=1e-14) + assert_allclose( + actual.f_statistic, + expected.f_statistic.stat, + rtol=2e-9, + atol=2e-11, + ) + assert_allclose( + actual.f_pvalue, + expected.f_statistic.pval, + rtol=2e-8, + atol=1e-14, + ) assert actual.f_df == ( float(expected.f_statistic.df), float(expected.f_statistic.df_denom), @@ -128,24 +172,33 @@ def test_two_way_panelols_matches_linearmodels_standard_diagnostics(): assert_allclose(sg._panel_cov_params, lm.cov.to_numpy(), rtol=5e-9, atol=5e-11) -def test_pooled_between_and_first_difference_match_linearmodels_fit_statistics(): +def test_pooled_and_between_match_linearmodels_on_general_unbalanced_panel(): X, y, entity, time = _panel(seed=1262, unbalanced=True) - y_lm, X_lm_const = _lm_data(X, y, entity, time, constant=True) - lm_pool = LMPooledOLS(y_lm, X_lm_const).fit(cov_type="unadjusted", debiased=True) + + lm_pool = LMPooledOLS(y_lm, X_lm_const).fit( + cov_type="unadjusted", debiased=True + ) sg_pool = PooledOLS().fit(X, y, entity_ids=entity) assert_allclose(sg_pool.coef_, lm_pool.params.to_numpy(), rtol=2e-10, atol=2e-11) _assert_r2(sg_pool.fit_statistics_, lm_pool) _assert_model_f(sg_pool.fit_statistics_, lm_pool) - lm_between = LMBetweenOLS(y_lm, X_lm_const).fit(cov_type="unadjusted", debiased=True) + lm_between = LMBetweenOLS(y_lm, X_lm_const).fit( + cov_type="unadjusted", debiased=True + ) sg_between = BetweenOLS().fit(X, y, entity_ids=entity) - assert_allclose(sg_between.coef_, lm_between.params.to_numpy(), rtol=2e-10, atol=2e-11) + assert_allclose( + sg_between.coef_, lm_between.params.to_numpy(), rtol=2e-10, atol=2e-11 + ) _assert_r2(sg_between.fit_statistics_, lm_between) _assert_model_f(sg_between.fit_statistics_, lm_between) - y_lm_fd, X_lm_fd = _lm_data(X, y, entity, time, constant=False) - lm_fd = LMFirstDifferenceOLS(y_lm_fd, X_lm_fd).fit( + +def test_first_difference_matches_linearmodels_when_transformed_sample_is_common(): + X, y, entity, time = _gap_free_unbalanced_panel() + y_lm, X_lm = _lm_data(X, y, entity, time, constant=False) + lm_fd = LMFirstDifferenceOLS(y_lm, X_lm).fit( cov_type="unadjusted", debiased=True ) sg_fd = FirstDifferenceOLS().fit( From 67a8223eceedc562febe903a7ded07a11d52f304 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 13:14:51 +0800 Subject: [PATCH 035/165] test: strengthen Panel Stage B physical inference gate --- dev/benchmarks/validate_panel_stage_b_gpu.py | 53 ++++++++++++++------ 1 file changed, 37 insertions(+), 16 deletions(-) diff --git a/dev/benchmarks/validate_panel_stage_b_gpu.py b/dev/benchmarks/validate_panel_stage_b_gpu.py index afc164dcf..6384d5676 100644 --- a/dev/benchmarks/validate_panel_stage_b_gpu.py +++ b/dev/benchmarks/validate_panel_stage_b_gpu.py @@ -4,7 +4,9 @@ This is a correctness/backend-provenance gate, not a performance benchmark. It validates the new parameter-based fit statistics and specification tests on balanced and unbalanced panels against the NumPy implementation while proving -that requested CuPy/Torch CUDA backends actually execute. +that requested CuPy/Torch CUDA backends actually execute. It also rechecks the +maintained coefficient-inference outputs so Stage-B integration cannot regress +the Stage-A bse/t/p/CI/df contracts. """ from __future__ import annotations @@ -133,6 +135,12 @@ def _test_result(result): def _model_snapshot(model): payload = { "coef": _array(model.coef_).ravel(), + "bse": _array(model.bse_).ravel(), + "tvalues": _array(model.tvalues_).ravel(), + "pvalues": _array(model.pvalues_).ravel(), + "conf_int": _array(model.conf_int_), + "nobs": int(model.nobs), + "df_resid": int(model.df_resid), "fit_statistics": _fit_stats(model), } covariance = getattr(model, "_panel_cov_params", None) @@ -258,15 +266,32 @@ def _compare_test_result(reference, candidate, *, rtol, atol, label): return differences +def _max_abs_difference(actual, expected): + if actual.size == 0: + return 0.0 + return float(np.max(np.abs(actual - expected))) + + def _compare_model(reference, candidate, *, rtol, atol, label): differences = {} - np.testing.assert_allclose( - candidate["coef"], reference["coef"], rtol=rtol, atol=atol, - err_msg=f"{label}.coef", - ) - differences["coef"] = float( - np.max(np.abs(candidate["coef"] - reference["coef"])) - ) + for field in ("coef", "bse", "tvalues", "pvalues", "conf_int"): + np.testing.assert_allclose( + candidate[field], + reference[field], + rtol=rtol, + atol=atol, + err_msg=f"{label}.{field}", + ) + differences[field] = _max_abs_difference( + candidate[field], reference[field] + ) + + for field in ("nobs", "df_resid"): + if int(candidate[field]) != int(reference[field]): + raise AssertionError( + f"{label}.{field}: {candidate[field]} != {reference[field]}" + ) + differences[field] = 0.0 for field, expected in reference["fit_statistics"].items(): actual = candidate["fit_statistics"][field] @@ -293,13 +318,9 @@ def _compare_model(reference, candidate, *, rtol, atol, label): atol=atol, err_msg=f"{label}.diagnostic_covariance", ) - differences["diagnostic_covariance"] = float( - np.max( - np.abs( - candidate["diagnostic_covariance"] - - reference["diagnostic_covariance"] - ) - ) + differences["diagnostic_covariance"] = _max_abs_difference( + candidate["diagnostic_covariance"], + reference["diagnostic_covariance"], ) for test_name in ("pooling_f", "bp_lm"): @@ -424,7 +445,7 @@ def main(): results[backend] = backend_payload payload = { - "schema_version": 1, + "schema_version": 2, "generated_at": datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"), "git_sha": sha, "working_tree_clean": True, From e72be284d91939d86553074351764e33eb0c5a71 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 13:17:30 +0800 Subject: [PATCH 036/165] docs: document Panel Stage B diagnostics in Chinese --- docs/cn/models/panel.md | 253 ++++++++++++++++++++++++++++++++-------- 1 file changed, 207 insertions(+), 46 deletions(-) diff --git a/docs/cn/models/panel.md b/docs/cn/models/panel.md index de91a7f84..8f4b2f93e 100644 --- a/docs/cn/models/panel.md +++ b/docs/cn/models/panel.md @@ -1,7 +1,7 @@ # Panel 模型 > 语言：中文 -> 最后更新：2026-07-24 +> 最后更新：2026-08-08 > 页面定位：模型文档 > 切换：[English](../../en/models/panel.md) @@ -10,13 +10,15 @@ `statgpu.panel` 提供六类面板数据估计器： - `PanelOLS`：个体和/或时间固定效应； -- `RandomEffects`：可行 GLS 随机效应； +- `RandomEffects`：Swamy-Arora 可行 GLS 随机效应； - `PooledOLS`：不去均值的堆叠 OLS； - `BetweenOLS`：在个体均值上回归； - `FirstDifferenceOLS`：个体内一阶差分； - `FamaMacBeth`：逐期横截面回归后对系数取平均。 -数组输入的数值路径支持 NumPy、CuPy CUDA 与 Torch CUDA。formula 构造以及字符串/分类 entity、time、cluster 标签属于明确的 CPU 元数据边界，只会将对齐后的紧凑编码传入数值后端。显式 GPU device 不会静默回退 CPU。 +数组输入的数值路径支持 NumPy、CuPy CUDA 与 Torch CUDA。formula 构造以及字符串/分类 entity、time、cluster 标签属于明确的 CPU 元数据边界，只会把对齐后的紧凑编码传入数值后端。显式 GPU device 不会静默回退 CPU。 + +Tier-1 Panel 路线的 Stage B 在不改变 Stage-A 系数、预测、协方差归一化和 legacy inference 契约的前提下，新增参数型 fit statistics 和三类结构化 specification test。 ## 路径 @@ -28,22 +30,29 @@ from statgpu.panel import ( BetweenOLS, FirstDifferenceOLS, FamaMacBeth, + PanelTestResult, + PanelFitStatistics, + hausman_test, + pooling_f_test, + breusch_pagan_lm_test, clustered_covariance, two_way_clustered_covariance, hac_covariance, ) ``` +诊断结果类和三类检验函数也从顶层 `statgpu` 导出。 + ## 模型汇总 -| 模型 | 变换 | 主要推断选项 | -|---|---|---| -| `PanelOLS` | 个体/时间组内变换 | nonrobust、HC1 robust、clustered | -| `RandomEffects` | Swamy-Arora 可行 GLS | nonrobust | -| `PooledOLS` | 堆叠 OLS | nonrobust、robust、clustered、HAC | -| `BetweenOLS` | 个体均值 | nonrobust、robust、clustered | -| `FirstDifferenceOLS` | 个体内一阶差分 | nonrobust、robust | -| `FamaMacBeth` | 逐期横截面回归 | nonrobust、Newey-West | +| 模型 | 变换 | 主要推断选项 | Stage-B fit statistics | +|---|---|---|---| +| `PanelOLS` | 个体/时间组内变换 | nonrobust、HC1 robust、clustered | within/between/overall R²、adjusted R²、classical model F、pooling F | +| `RandomEffects` | Swamy-Arora 可行 GLS | nonrobust | within/between/overall R²、adjusted R²、classical model F、Hausman 输入 | +| `PooledOLS` | 堆叠 OLS | nonrobust、robust、clustered、HAC | overall R² 始终可用；提供 `entity_ids` 后增加 within/between R² 和 BP-LM；另有 adjusted R² 与 classical model F | +| `BetweenOLS` | 个体均值 | nonrobust、robust | within/between/overall R²、adjusted R²、classical model F | +| `FirstDifferenceOLS` | 个体内一阶差分 | nonrobust、robust | within/between/overall R²、差分拟合空间的 adjusted R²、classical model F | +| `FamaMacBeth` | 逐期横截面回归 | nonrobust、Newey-West | 参数型 within/between/overall R²；不定义 residual-OLS adjusted R² 或 model F | ## 核心估计方程 @@ -55,7 +64,7 @@ y_{it}^{\mathrm{within}} = y_{it} - \bar y_{i\cdot}, X_{it}^{\mathrm{within}} = X_{it} - \bar X_{i\cdot}. $$ -个体与时间双向固定效应会进一步减去时间均值并加回总体均值。 +个体和时间双向固定效应会进一步移除时间均值并加回总体均值。 `PooledOLS` 拟合 @@ -63,32 +72,174 @@ $$ \hat\beta = X^+ y, $$ -其中 \(X^+\) 在需要时表示 Moore-Penrose 伪逆。`BetweenOLS` 对个体均值执行 OLS，`FirstDifferenceOLS` 对 Δ\(X\) 和 Δ\(y\) 执行 OLS，`FamaMacBeth` 对逐期系数向量求平均。 +其中 \(X^+\) 在需要时表示 Moore-Penrose 伪逆。`BetweenOLS` 对个体均值执行 OLS，`FirstDifferenceOLS` 对 \(\Delta X\) 和 \(\Delta y\) 执行 OLS，`FamaMacBeth` 对逐期系数向量求平均。 -## 协方差与推断 +## 协方差与现有推断 | `cov_type` | 行为 | |---|---| | `"nonrobust"` | 经典 OLS 协方差和 t 推断 | | `"robust"` | HC1 sandwich 协方差和渐近正态推断 | -| `"clustered"` | 单向或双向聚类稳健协方差 | +| `"clustered"` | 在相应 estimator 支持范围内使用聚类稳健协方差 | | `"hac"` | `PooledOLS` 使用 Bartlett/Newey-West HAC | -| `"newey-west"` | 对 `FamaMacBeth` 系数路径应用 HAC | +| `"newey-west"` | 对 `FamaMacBeth` 系数时间序列应用 HAC | + +Stage B 不修改原有 `bse_`、`tvalues_`、`pvalues_`、`conf_int_` 或 estimator-specific covariance 定义。RandomEffects robust covariance、HC0/HC2/HC3、Driscoll-Kraay 和扩展 cluster correction 仍属于后续 Stage C。 ### PooledOLS HAC 时间排序 -对 `PooledOLS(cov_type="hac")`，应在 `fit` 中传入 `time_index=`。实现会验证该侧数组，并使用稳定时间排序，同时保持所有数值数组对齐。因此，只要时间标签不变，对原始行进行排列不会改变 HAC 协方差（除数值误差外）。 +对 `PooledOLS(cov_type="hac")`，应向 `fit` 传入 `time_index=`。实现采用稳定时间排序，并让 X、y 和 Stage-B entity diagnostic metadata 使用同一个 permutation。因此 BP-LM 与参数型 R² 不会因为 HAC 排序后仍使用旧 entity metadata 而发生错位。 ### 秩亏 PooledOLS 秩亏设计需要区分拟合空间与系数空间： -- 拟合、预测、残差、RSS、有效秩和拟合空间比较仍然有效； -- `df_resid` 按 `nobs - rank(X)` 计算，而不是 `nobs - n_columns`； -- 精确共线时，单个系数不唯一； -- 因此系数级协方差、BSE、检验统计量、p 值和置信区间不可唯一识别，应标记为 `NOT_COMPARABLE`，而不是运行错误，也不能作为唯一推断结果报告。 +- 拟合、预测、残差、RSS、有效 rank 与拟合空间比较仍然有效； +- `df_resid` 使用 `nobs - rank(X)`，而不是 `nobs - n_columns`； +- 精确共线时单个系数不唯一； +- 因而系数级 covariance、BSE、test statistic、p-value 和 confidence interval 不应被解释为唯一识别的系数推断。 + +Stage-B model-F 的 restriction rank 使用有效数值 rank，而不是直接使用原始列数。 + +## 标准化 `fit_statistics_` + +支持的拟合对象提供结构化 `PanelFitStatistics`： + +```python +stats = model.fit_statistics_ + +stats.rsquared_within +stats.rsquared_between +stats.rsquared_overall +stats.rsquared_adj +stats.f_statistic +stats.f_pvalue +stats.f_df +stats.metadata +``` + +### 参数型 R² + +within/between/overall R² 采用与 `linearmodels` 对齐的 parameter-based 定义：各统计量直接评价同一个拟合系数向量，而不是使用 fitted-value correlation 的平方。 + +给定 \(\hat\beta\)： + +- **overall R²** 在 level panel 上评价 \(y-X\hat\beta\)； +- **between R²** 在个体均值上评价 \(\bar y_i-\bar X_i\hat\beta\)； +- **within R²** 在 entity-demeaned 的 y 和 X 上评价同一系数向量。 + +只有 level regressor design 中存在实际可识别的常数项时，overall 和 between total sum of squares 才中心化。固定效应本身不会自动改变这一规则。若 total sum of squares 为 0，Stage-B 标准字段返回 `0.0`，并在 `metadata["degenerate_total_ss"]` 中标记。 + +### Legacy `PanelOLS.rsquared_within` + +`PanelOLS.rsquared_within` 为兼容 Stage A 保持原样。双向 FE 下，它描述历史上的 entity+time 完整 transformed fit，因此可能与标准化的 entity-within `fit_statistics_.rsquared_within` 不同。Stage B 不覆盖旧属性，并在 fit-statistics metadata 中保留兼容值。 + +### Adjusted R² 与 diagnostic df + +新的标准化 diagnostics 使用完整 fixed-effect nuisance space 的 rank。当前 `PanelOLS` 不保留 exogenous intercept，因此标准 nuisance-effect rank 为： + +- 仅 entity effects：\(N\)； +- 仅 time effects：\(T\)； +- entity + time effects：\(N+T-1\)。 + +若 transformed slope design 的数值 rank 为 \(r_X\)，Stage B 使用 + +$$ +\mathrm{df}_{\mathrm{resid,diag}} += n-r_X-r_{\mathrm{effects}}, +$$ + +以及 + +$$ +\mathrm{df}_{\mathrm{total,diag}} += n-r_{\mathrm{effects}} +$$ + +来计算标准 FE model F 与 adjusted R²。 + +这套 diagnostic df 与历史公开 `PanelOLS.df_resid` 明确分离；旧 df 继续服务已有 covariance、t statistic、p-value、confidence interval 与 summary。Hausman 使用一份仅供 diagnostic 的小型 FE covariance，并按标准 nuisance-rank denominator 重标度；Stage-A 公共 BSE/CI 不受影响。 + +### Classical model F + +对 OLS-style panel estimator，Stage B 报告主拟合空间上的 classical homoskedastic joint-slope F： + +$$ +F= +\frac{(RSS_R-RSS_U)/q} + {RSS_U/\mathrm{df}_{\mathrm{resid}}}, +$$ + +其中 \(q\) 是有效 restriction rank。即使 estimator 的 coefficient covariance 使用 robust 或 clustered 选项，这一字段也不会静默变成 robust Wald test。 -PR79 验证管线在秩亏场景中继续检查 prediction、RSS、rank 与拟合空间合同，同时排除不可识别的系数空间比较。 +`FamaMacBeth` 不定义 residual-OLS model F 或 adjusted R²，因为其 covariance 来自逐期横截面系数时间序列；Stage B 不会把 beta-series inference 重命名成 residual OLS inference。 + +## Specification Tests + +所有 specification test 都返回 `PanelTestResult`。在计量意义上不适用的情况返回 `applicable=False` 并给出 `reason`；真正的 API 编程错误仍正常抛出异常。 + +### Pooling F test + +对至少包含一个固定效应的已拟合 `PanelOLS`： + +```python +result = fe.pooling_f_test() +# 或 +result = pooling_f_test(fe) +``` + +经典 poolability 原假设是所有纳入的固定效应联合为 0。统计量使用**同一个对齐后的估计样本**比较 fixed-effect model 与其 nested pooled regression。 + +当 FE level design 没有显式常数时，pooled null 会先从 y 和 X 中投影掉共同常数，再拟合 slope，避免把共同均值误计入被检验的 fixed effects。分子和分母自由度由有效 nested-model rank 推导，而不是硬编码 effect count。 + +即使 FE 对象的系数推断采用 robust 或 clustered covariance，这个 pooling F 仍是 classical/homoskedastic test。 + +### 个体随机效应 Breusch-Pagan LM + +向 `PooledOLS.fit()` 提供 `entity_ids`： + +```python +pooled = PooledOLS().fit(X, y, entity_ids=entity_ids) +result = pooled.breusch_pagan_lm_test() +# 或 +result = breusch_pagan_lm_test(pooled) +``` + +这里是 **panel error-components Breusch-Pagan LM test**，不是横截面异方差的 Breusch-Pagan test。Stage B 实现 one-way entity 版本，并包含 `plm::plmtest(type="bp", effect="individual")` 使用的 Baltagi-Li incomplete/unbalanced-panel 公式。 + +原假设是 entity random-effect variance 为 0。至少需要两个 entity、正的 pooled RSS，并且至少一个 entity 有重复观测。没有 `entity_ids` 时返回结构化 inapplicable 结果，不会根据行顺序猜测 panel structure。 + +### Classical Hausman：FE 与 RE + +```python +fe = PanelOLS(entity_effects=True, cov_type="nonrobust").fit( + X, y, entity_ids=entity_ids +) +re = RandomEffects().fit(X, y, entity_ids=entity_ids) + +result = fe.hausman_test(re) +# 或 +result = hausman_test(fe, re) +``` + +Stage B 实现 one-way entity FE-versus-RE 的经典二次型 Hausman： + +$$ +H=(\hat\beta_{FE}-\hat\beta_{RE})^\top + (V_{FE}-V_{RE})^{-1} + (\hat\beta_{FE}-\hat\beta_{RE}). +$$ + +适用性规则是显式的： + +- FE 必须只有 one-way entity effects； +- FE coefficient covariance 必须是 classical/nonrobust； +- FE 与 RE 必须来自同一个对齐后的 X/y/entity 样本和共同 slope design； +- 行/样本一致性使用紧凑的 backend-native numerical fingerprint 检查，而不是仅比较 shape； +- intercept 不进入共同 slope 比较； +- covariance difference 若实质上 indefinite，则返回 inapplicable，不通过 eigenvalue clipping 强行制造统计量。 + +若 covariance difference 为 positive semidefinite 但 rank deficient，statgpu 提供显式记录的 generalized-inverse extension：只在 coefficient difference 位于 identified range 内时计算，并使用 numerical rank 作为 chi-square df。metadata 会记录 `used_pinv=True` 和 `singular PSD generalized-inverse Hausman`。Stage B 不实现 robust auxiliary-regression Hausman。 ## 参数与 fit 签名 @@ -104,9 +255,11 @@ PanelOLS( ``` ```python -model.fit(y, X, entity_ids=entity_ids, time_ids=time_ids, cluster=cluster) +model.fit(X, y, entity_ids=entity_ids, time_ids=time_ids, cluster=cluster) ``` +formula 输入也可使用已有 pipe syntax，例如 `"y ~ x1 + x2 | entity"`。formula 的 missing-row filtering 会同步对齐 observation-level side arrays。 + ### `PooledOLS` ```python @@ -120,10 +273,16 @@ PooledOLS( ``` ```python -model.fit(X, y, cluster=None, time_index=None) +model.fit( + X, + y, + cluster=None, + time_index=None, + entity_ids=None, +) ``` -clustered 推断需要 `cluster`。HAC 推断强烈建议传入 `time_index`，该参数用于定义稳定时间顺序。 +clustered inference 需要 `cluster`。`time_index` 定义 HAC 的稳定时间排序。`entity_ids` 是可选项，不改变系数；提供后会启用标准化 within/between R² 与 panel BP-LM。 ### 其他模型 @@ -140,11 +299,13 @@ FamaMacBeth( ) ``` +`FamaMacBeth.fit(..., entity_ids=None)` 中的可选 entity IDs 只用于 Stage-B within/between R²；beta-series estimation 与 covariance path 保持不变。 + ## CPU 与 GPU 示例 ```python import numpy as np -from statgpu.panel import PanelOLS, PooledOLS, FamaMacBeth +from statgpu.panel import PanelOLS, PooledOLS, RandomEffects n_entities, n_times = 50, 10 n = n_entities * n_times @@ -153,20 +314,20 @@ time_ids = np.tile(np.arange(n_times), n_entities) X = np.random.default_rng(0).normal(size=(n, 3)) y = X @ np.array([1.0, -0.5, 0.3]) + np.random.default_rng(1).normal(size=n) * 0.1 -# CPU 固定效应。 -fe = PanelOLS(entity_effects=True, cov_type="robust", device="cpu") -fe.fit(y, X, entity_ids=entity_ids) +fe = PanelOLS(entity_effects=True, device="cpu").fit( + X, y, entity_ids=entity_ids +) +print(fe.fit_statistics_.rsquared_within) +print(fe.pooling_f_test()) -# 使用显式时间顺序的 HAC PooledOLS。 -pooled_hac = PooledOLS(cov_type="hac", device="cpu") -pooled_hac.fit(X, y, time_index=time_ids) +pooled = PooledOLS(device="cpu").fit(X, y, entity_ids=entity_ids) +print(pooled.breusch_pagan_lm_test()) -# CuPy CUDA Fama-MacBeth；元数据标签可保留在 CPU。 -fm = FamaMacBeth(cov_type="newey-west", device="cuda") -fm.fit(X, y, time_ids=time_ids) +re = RandomEffects(device="cpu").fit(X, y, entity_ids=entity_ids) +print(fe.hausman_test(re)) ``` -Torch CUDA 路径应传入 CUDA tensor，并设置 `device="torch"`。数组输入的公开预测方法会保留 estimator 后端。 +CuPy CUDA 使用 `device="cuda"`；Torch CUDA 使用 CUDA tensor 并设置 `device="torch"`。Stage-B sufficient-statistic accumulation 跟随所选数值 backend；只有紧凑 metadata、最终 scalar 与小型 covariance matrix 跨越 CPU metadata boundary。 ## 输出 @@ -174,28 +335,28 @@ Torch CUDA 路径应传入 CUDA tensor，并设置 `device="torch"`。数组输 - `coef_`； - 在系数空间可识别时的 `bse_`、`tvalues_`、`pvalues_`、`conf_int_`； -- 适用模型的 `rsquared` 或 `rsquared_within`； -- `nobs`、`df_resid` 与有效秩； +- 历史兼容的 `rsquared` 或 `rsquared_within`； +- 标准化的 `fit_statistics_`； +- `nobs`、`df_resid` 与有效 rank； - `FamaMacBeth` 的 `betas_`、`cov_params_` 与 `n_periods`。 -对精确秩亏的 `PooledOLS`，下游使用者不得将系数级推断解释为唯一识别结果。 +`PanelTestResult` 包含 `statistic`、`pvalue`、`distribution`、`df`、`null`、`alternative`、`applicable`、`reason` 和 `metadata`。 ## Formula 与元数据边界 -formula 计算可能因缺失值删除行。entity、time、cluster 等侧数组会按保留行同步对齐。字符串或分类标签在 CPU 上 factorize；数值变换和回归仍在所选后端执行。 +formula evaluation 可能因为 missing value 删除行。entity、time、cluster 等 side array 会与保留行同步对齐。字符串和分类标签在 CPU 上 factorize；数值变换与 sufficient-statistic calculation 继续留在所选 backend。Hausman 只保存紧凑 sample/design fingerprint 与小型 covariance matrix，不保存第二份完整 CPU design copy。 ## 验证 -PR #79 已验证 NumPy、CuPy CUDA 与 Torch CUDA 的维护中面板路径。最终维护中的真实 GPU 测试在 Tesla P100 上 **33/33** 通过，覆盖后端保持的 `PooledOLS.predict()` 与秩亏 `NOT_COMPARABLE` 合同。exact-head GitHub Actions 同时通过 Python 3.9–3.12 regression matrix 与完整 CPU suite。 - -相关内容： +Stage A / PR #119 建立共享 Panel framework，并在 Tesla P100 上通过 10 个 CuPy + 10 个 Torch exact-head physical cases。 -- `dev/reviews/pr79_physical_gpu_validation.md`； -- `dev/tests/test_pr79_physical_gpu.py`； -- Issue #83：清理未纳入维护测试树的旧 GPU 诊断脚本。 +Stage B 增加 maintained analytic/fitted-model regression tests、formula/missing-row alignment、Python 3.9 + Torch 2.0 CPU parity，以及可执行的 `linearmodels==7.0` external-definition gate。最终 promotion 还要求 `dev/benchmarks/validate_panel_stage_b_gpu.py` 在 clean exact commit 上同时通过 CuPy 与 Torch CUDA；该 runner 是 correctness/provenance gate，而不是性能 benchmark，并会同时复核 Stage-A 的 coef/BSE/t/p/CI/df contract。 ## 参考文献 +- Hausman, J. A. (1978). Specification Tests in Econometrics. +- Breusch, T. S., & Pagan, A. R. (1980). The Lagrange Multiplier Test and its Applications to Model Specification in Econometrics. +- Baltagi, B. H., & Li, Q. (1990). A Lagrange Multiplier Test for the Error Components Model with Incomplete Panels. - White, H. (1980). A heteroskedasticity-consistent covariance matrix estimator. - Newey, W. K., & West, K. D. (1987). A simple, positive semi-definite, heteroskedasticity and autocorrelation consistent covariance matrix. - Fama, E. F., & MacBeth, J. D. (1973). Risk, return, and equilibrium. From 4a18cc2427a0d2d69cdb1ea8d9694385783944d3 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 13:19:33 +0800 Subject: [PATCH 037/165] docs: add Panel Stage B changelog summary --- CHANGELOG.md | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 732d6bfc5..f65151c32 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,12 @@ All notable changes to statgpu are documented here, organized by release and dat ## 2026-08-08 +### PR #122 — Panel Tier-1 diagnostics Stage B + +- Added structured Panel `fit_statistics_` with parameter-based within/between/overall R², adjusted R², and classical model F statistics while preserving Stage-A inference and legacy df/R² attributes. +- Added classical pooling F, one-way entity Breusch-Pagan LM (including Baltagi-Li unbalanced panels), and one-way classical FE-vs-RE Hausman with explicit applicability diagnostics. +- Added NumPy/CuPy/Torch coverage, formula-row alignment, maintained Torch 2.0 CPU tests, executable linearmodels 7.0 definition alignment, and an exact-head physical GPU acceptance runner that rechecks coefficient inference as well as Stage-B diagnostics. + ### PR #121 — CuPy inverse-quantile LUT correctness - Fixed CuPy `betaincinv` and `gammaincinv` LUT cache tuple ordering so inverse quantiles no longer collapse to boundary values and downstream confidence intervals retain their correct width. From 83c96a2db68725e70ddc10716d7de1b942d79a64 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 13:20:17 +0800 Subject: [PATCH 038/165] docs: add Panel Stage B English changelog --- docs/en/changelog.md | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/docs/en/changelog.md b/docs/en/changelog.md index d9126e537..a7d2133a4 100644 --- a/docs/en/changelog.md +++ b/docs/en/changelog.md @@ -7,6 +7,17 @@ ## 2026-08-08 +### PR #122 — Panel Tier-1 diagnostics Stage B + +- Added public structured `PanelTestResult` and `PanelFitStatistics` outputs plus standardized `fit_statistics_` on the maintained panel estimators. The new fit statistics use parameter-based within/between/overall R², an explicitly defined adjusted R², and a classical homoskedastic model F statistic where the estimator has a residual-OLS fit space. +- Kept Stage-A coefficient inference and legacy R²/df behavior unchanged. In particular, `PanelOLS` continues to expose its historical public residual df and BSE/t/p/CI, while Stage-B diagnostics use a separate standard fixed-effect nuisance-rank df; the classical Hausman calculation consumes only a diagnostic small covariance rescaled to that standard denominator. +- Added the classical pooling F test for fixed effects, the one-way entity error-components Breusch-Pagan LM test including the Baltagi-Li unbalanced-panel formula, and the classical one-way entity FE-vs-RE Hausman test. Inapplicable econometric cases return structured reasons; singular positive-semidefinite Hausman covariance differences use a documented generalized-inverse/rank extension, while materially indefinite differences are rejected. +- Added optional `entity_ids` to `PooledOLS.fit()` and `FamaMacBeth.fit()` solely for Stage-B within/between fit statistics and the panel BP-LM path. Pooled HAC sorting now carries entity diagnostic metadata through the same stable permutation as X/y. Formula missing-row filtering aligns observation-level side arrays before diagnostics are formed. +- Added analytic/fitted regressions, maintained Python 3.9 + Torch 2.0 CPU parity, and an executable `linearmodels==7.0` definition-alignment job. FirstDifference external comparison is restricted to panels where both implementations use the same transformed sample; Stage B does not silently redefine the Stage-A adjacent-observed-row differencing contract for internal time gaps. +- Added `dev/benchmarks/validate_panel_stage_b_gpu.py` as the final exact-head physical correctness/provenance gate. The schema-2 runner compares NumPy against requested CuPy/Torch CUDA for Stage-B diagnostics and fit statistics and rechecks `coef`, BSE, t-values, p-values, confidence intervals, `nobs`, and `df_resid` so the new diagnostic integration cannot mask a Stage-A inference regression. Physical GPU promotion remains pending until this runner passes on a clean exact commit. + +Related: Issue #93 and pull request #122. + ### PR #121 — CuPy inverse-quantile LUT correctness - Corrected the CuPy LUT cache tuple order used by `betaincinv()` and `gammaincinv()`. The LUT builders already stored `(x_grid, y_grid)`, but the cached values were unpacked in reverse, so inverse lookup searched the wrong axis and could collapse quantiles to clipped boundary values. From 636988751bcbfad3442d24d3073cdfcd2b3ac637 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 13:21:15 +0800 Subject: [PATCH 039/165] docs: add Panel Stage B Chinese changelog --- docs/cn/changelog.md | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/docs/cn/changelog.md b/docs/cn/changelog.md index 842af67e9..659699d0e 100644 --- a/docs/cn/changelog.md +++ b/docs/cn/changelog.md @@ -7,6 +7,17 @@ ## 2026-08-08 +### PR #122 — Panel Tier-1 diagnostics Stage B + +- 新增公开的结构化 `PanelTestResult`、`PanelFitStatistics` 以及维护中 panel estimator 的标准化 `fit_statistics_`。新的 fit statistics 包含 parameter-based within/between/overall R²、显式定义的 adjusted R²，以及在存在 residual-OLS 拟合空间时的 classical homoskedastic model F。 +- Stage-A 的 coefficient inference 与 legacy R²/df 行为保持不变。特别是 `PanelOLS` 继续公开历史 residual df 和 BSE/t/p/CI；Stage-B diagnostics 使用单独的标准 fixed-effect nuisance-rank df，经典 Hausman 只读取按该标准 denominator 重标度的小型 diagnostic covariance，不修改公共 inference。 +- 新增 fixed-effects classical pooling F、one-way entity error-components Breusch-Pagan LM（包含 Baltagi-Li unbalanced-panel 公式）以及 classical one-way entity FE-vs-RE Hausman。计量上不适用的情况返回结构化 reason；Hausman covariance difference 若为奇异 PSD，则使用明确记录的 generalized-inverse/rank extension；若实质 indefinite，则直接报告不可用。 +- `PooledOLS.fit()` 与 `FamaMacBeth.fit()` 的可选 `entity_ids` 只用于 Stage-B within/between fit statistics 和 panel BP-LM。Pooled HAC 稳定排序现在让 entity diagnostic metadata 与 X/y 使用完全相同的 permutation；formula missing-row filtering 也会在形成 diagnostics 前对齐 observation-level side arrays。 +- 增加 analytic/fitted regression、维护中的 Python 3.9 + Torch 2.0 CPU parity，以及可执行的 `linearmodels==7.0` definition-alignment job。FirstDifference 的外部比较只在两边 transformed sample 定义一致的 panel 上执行；Stage B 不会为了 external gate 静默改变 Stage-A 对内部缺期采用 adjacent-observed-row differencing 的既有契约。 +- 新增 `dev/benchmarks/validate_panel_stage_b_gpu.py` 作为最终 exact-head physical correctness/provenance gate。schema-2 runner 会在请求的 CuPy/Torch CUDA 上对照 NumPy 检查 Stage-B diagnostics/fit statistics，并重新核验 `coef`、BSE、t-value、p-value、confidence interval、`nobs` 与 `df_resid`，以保证新增 diagnostics 不会掩盖 Stage-A inference regression。当前仍需在 clean exact commit 上完成这项物理 GPU promotion。 + +关联：Issue #93 与 pull request #122。 + ### PR #121 — CuPy inverse-quantile LUT 正确性修复 - 修正 CuPy `betaincinv()` 与 `gammaincinv()` 的 LUT cache tuple 顺序。LUT builder 原本已经按 `(x_grid, y_grid)` 存储，但缓存读取时反向解包，导致 inverse lookup 在错误坐标轴上搜索，并可能把 quantile 推到 clipped boundary。 @@ -133,4 +144,4 @@ Stage B diagnostics 与 Stage C covariance 扩展继续由 Issue #93 跟踪；St ## 更早的历史记录 截至 2026-08-03 的详细条目保留在 -[归档 changelog](changelog-history-through-2026-08-03.markdown)。 +[归档 changelog](changelog-history-through-2026-08-03.markdown)。 \ No newline at end of file From 90c7de55327d2adf1139a71d63d4aecd0eda6ee6 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 14:26:16 +0800 Subject: [PATCH 040/165] docs: record PR122 physical GPU validation --- dev/reviews/pr122_physical_gpu_validation.md | 43 ++++++++++++++++++++ 1 file changed, 43 insertions(+) create mode 100644 dev/reviews/pr122_physical_gpu_validation.md diff --git a/dev/reviews/pr122_physical_gpu_validation.md b/dev/reviews/pr122_physical_gpu_validation.md new file mode 100644 index 000000000..0695d987f --- /dev/null +++ b/dev/reviews/pr122_physical_gpu_validation.md @@ -0,0 +1,43 @@ +# PR #122 Panel Stage B physical GPU validation + +Validated implementation head: `636988751bcbfad3442d24d3073cdfcd2b3ac637`. + +Environment reported by the physical run: + +- NVIDIA Tesla P100 +- Python 3.9.16 +- CuPy 13.6.0 +- PyTorch 2.0.0 + +Top-level artifact contract: + +- `schema_version = 2` +- `git_sha = 636988751bcbfad3442d24d3073cdfcd2b3ac637` +- `working_tree_clean = true` +- `status = success` + +CuPy acceptance: + +- 15/15 model cases succeeded with `executed_backend = cupy`; +- balanced and unbalanced PooledOLS, unsorted-time HAC PooledOLS, BetweenOLS, FirstDifferenceOLS, one-way PanelOLS, RandomEffects, and FamaMacBeth all succeeded; +- balanced two-way PanelOLS succeeded; +- balanced and unbalanced Hausman diagnostic cases completed consistently with `applicable = false`. + +Torch acceptance: + +- 15/15 model cases succeeded with `executed_backend = torch`; +- balanced and unbalanced diagnostic cases succeeded; +- no silent CPU fallback was observed. + +Stage-B checks passed for the maintained model matrix: + +- parameter-based within/between/overall/adjusted R-squared; +- classical model F statistic and p-value where defined; +- PooledOLS Breusch-Pagan LM statistic/p-value; +- fixed-effects pooling F statistic/p-value; +- FE-vs-RE Hausman applicability/result parity; +- diagnostic covariance matrices. + +Stage-A regression checks also passed for `coef`, `bse`, `tvalues`, `pvalues`, `conf_int`, `nobs`, and `df_resid`. CuPy and Torch results remained within machine-precision-scale differences of the NumPy reference, so the Stage-B integration did not regress the Stage-A coefficient-inference contract. + +This record captures the physical acceptance summary supplied for the exact clean implementation head. PR promotion still requires the final hosted/doc-only head to remain green after any evidence-only documentation updates. From b619172cdb9ef5990aff4da41aab3ecc6743d173 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 14:26:50 +0800 Subject: [PATCH 041/165] docs: record PR122 physical GPU acceptance --- docs/en/changelog.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/en/changelog.md b/docs/en/changelog.md index a7d2133a4..816ca276e 100644 --- a/docs/en/changelog.md +++ b/docs/en/changelog.md @@ -14,7 +14,7 @@ - Added the classical pooling F test for fixed effects, the one-way entity error-components Breusch-Pagan LM test including the Baltagi-Li unbalanced-panel formula, and the classical one-way entity FE-vs-RE Hausman test. Inapplicable econometric cases return structured reasons; singular positive-semidefinite Hausman covariance differences use a documented generalized-inverse/rank extension, while materially indefinite differences are rejected. - Added optional `entity_ids` to `PooledOLS.fit()` and `FamaMacBeth.fit()` solely for Stage-B within/between fit statistics and the panel BP-LM path. Pooled HAC sorting now carries entity diagnostic metadata through the same stable permutation as X/y. Formula missing-row filtering aligns observation-level side arrays before diagnostics are formed. - Added analytic/fitted regressions, maintained Python 3.9 + Torch 2.0 CPU parity, and an executable `linearmodels==7.0` definition-alignment job. FirstDifference external comparison is restricted to panels where both implementations use the same transformed sample; Stage B does not silently redefine the Stage-A adjacent-observed-row differencing contract for internal time gaps. -- Added `dev/benchmarks/validate_panel_stage_b_gpu.py` as the final exact-head physical correctness/provenance gate. The schema-2 runner compares NumPy against requested CuPy/Torch CUDA for Stage-B diagnostics and fit statistics and rechecks `coef`, BSE, t-values, p-values, confidence intervals, `nobs`, and `df_resid` so the new diagnostic integration cannot mask a Stage-A inference regression. Physical GPU promotion remains pending until this runner passes on a clean exact commit. +- Added `dev/benchmarks/validate_panel_stage_b_gpu.py` as the final exact-head physical correctness/provenance gate. The schema-2 runner compares NumPy against requested CuPy/Torch CUDA for Stage-B diagnostics and fit statistics and rechecks `coef`, BSE, t-values, p-values, confidence intervals, `nobs`, and `df_resid` so the new diagnostic integration cannot mask a Stage-A inference regression. Physical validation passed on exact clean implementation head `636988751bcbfad3442d24d3073cdfcd2b3ac637` using Tesla P100, Python 3.9.16, CuPy 13.6.0, and PyTorch 2.0.0: all 15 CuPy and 15 Torch model cases plus balanced/unbalanced diagnostics succeeded with no CPU fallback, and the Stage-A inference regressions remained within machine-precision-scale differences of NumPy. Related: Issue #93 and pull request #122. From 7c7b10ea9c6aba54126a9e4f7155894f339618a8 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 14:27:24 +0800 Subject: [PATCH 042/165] docs: record PR122 physical GPU acceptance --- docs/cn/changelog.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/cn/changelog.md b/docs/cn/changelog.md index 659699d0e..ae1662bb4 100644 --- a/docs/cn/changelog.md +++ b/docs/cn/changelog.md @@ -14,7 +14,7 @@ - 新增 fixed-effects classical pooling F、one-way entity error-components Breusch-Pagan LM（包含 Baltagi-Li unbalanced-panel 公式）以及 classical one-way entity FE-vs-RE Hausman。计量上不适用的情况返回结构化 reason；Hausman covariance difference 若为奇异 PSD，则使用明确记录的 generalized-inverse/rank extension；若实质 indefinite，则直接报告不可用。 - `PooledOLS.fit()` 与 `FamaMacBeth.fit()` 的可选 `entity_ids` 只用于 Stage-B within/between fit statistics 和 panel BP-LM。Pooled HAC 稳定排序现在让 entity diagnostic metadata 与 X/y 使用完全相同的 permutation；formula missing-row filtering 也会在形成 diagnostics 前对齐 observation-level side arrays。 - 增加 analytic/fitted regression、维护中的 Python 3.9 + Torch 2.0 CPU parity，以及可执行的 `linearmodels==7.0` definition-alignment job。FirstDifference 的外部比较只在两边 transformed sample 定义一致的 panel 上执行；Stage B 不会为了 external gate 静默改变 Stage-A 对内部缺期采用 adjacent-observed-row differencing 的既有契约。 -- 新增 `dev/benchmarks/validate_panel_stage_b_gpu.py` 作为最终 exact-head physical correctness/provenance gate。schema-2 runner 会在请求的 CuPy/Torch CUDA 上对照 NumPy 检查 Stage-B diagnostics/fit statistics，并重新核验 `coef`、BSE、t-value、p-value、confidence interval、`nobs` 与 `df_resid`，以保证新增 diagnostics 不会掩盖 Stage-A inference regression。当前仍需在 clean exact commit 上完成这项物理 GPU promotion。 +- 新增 `dev/benchmarks/validate_panel_stage_b_gpu.py` 作为最终 exact-head physical correctness/provenance gate。schema-2 runner 会在请求的 CuPy/Torch CUDA 上对照 NumPy 检查 Stage-B diagnostics/fit statistics，并重新核验 `coef`、BSE、t-value、p-value、confidence interval、`nobs` 与 `df_resid`，以保证新增 diagnostics 不会掩盖 Stage-A inference regression。物理 GPU 验证已在精确 clean implementation head `636988751bcbfad3442d24d3073cdfcd2b3ac637` 上通过：Tesla P100、Python 3.9.16、CuPy 13.6.0、PyTorch 2.0.0；CuPy 与 Torch 各 15 个模型 case 以及 balanced/unbalanced diagnostics 全部成功，无 CPU fallback，Stage-A inference regression 与 NumPy 的差异保持在 machine-precision 量级。 关联：Issue #93 与 pull request #122。 From 1b1578249f47ffe09dde36db24f6b13f771ed78a Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 14:45:42 +0800 Subject: [PATCH 043/165] test: register PR122 physical validation for benchmark frontend --- dev/benchmarks/benchmark_coverage_matrix.json | 12 +- .../frontend_data/parsers/__init__.py | 2 + .../frontend_data/parsers/panel_stage_b.py | 199 ++++++++++ dev/benchmarks/frontend_data/registry.py | 2 + dev/benchmarks/frontend_sources.json | 24 ++ .../test_panel_stage_b_frontend_source.py | 101 +++++ .../panel_stage_b_pr122_p100_20260808.json | 371 ++++++++++++++++++ 7 files changed, 707 insertions(+), 4 deletions(-) create mode 100644 dev/benchmarks/frontend_data/parsers/panel_stage_b.py create mode 100644 dev/tests/test_panel_stage_b_frontend_source.py create mode 100644 results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260808.json diff --git a/dev/benchmarks/benchmark_coverage_matrix.json b/dev/benchmarks/benchmark_coverage_matrix.json index 01238a5a3..9c54673d2 100644 --- a/dev/benchmarks/benchmark_coverage_matrix.json +++ b/dev/benchmarks/benchmark_coverage_matrix.json @@ -82,18 +82,22 @@ }, { "capability_id": "panel-estimation", - "label": "Panel estimation coverage", + "label": "Panel estimation and diagnostics coverage", "status": "partial_canonical", "source_ids": [ - "new-modules-20260624-bcbdb676223b" + "new-modules-20260624-bcbdb676223b", + "panel-stage-b-pr122-20260808-882892c6e307" ], "representative_dimensions": [ "estimator", "backend", - "aligned_scale" + "aligned_scale", + "physical_validation", + "diagnostics", + "inference_regression" ], "issue": "#108", - "disposition": "Aligned PanelOLS and RandomEffects evidence exists; additional estimators and covariance variants remain open." + "disposition": "June timing rows cover aligned PanelOLS and RandomEffects. PR #122 adds canonical validation-only CuPy/Torch evidence for six estimators, Stage-B diagnostics, backend provenance, and Stage-A inference regression; broader performance/covariance timing remains open." }, { "capability_id": "gam-nonparametric", diff --git a/dev/benchmarks/frontend_data/parsers/__init__.py b/dev/benchmarks/frontend_data/parsers/__init__.py index 1edb4d459..0ac0a7d61 100644 --- a/dev/benchmarks/frontend_data/parsers/__init__.py +++ b/dev/benchmarks/frontend_data/parsers/__init__.py @@ -18,6 +18,7 @@ from .unsupervised import parse_unsupervised_benchmark from .new_modules_complete import parse_new_modules_with_anova_benchmark from .pr74_complete import parse_pr74_inference_benchmark +from .panel_stage_b import parse_panel_stage_b_physical_validation __all__ = [ "parse_penalized_glm_bench_perf", @@ -36,4 +37,5 @@ "parse_new_modules_benchmark", "parse_new_modules_with_anova_benchmark", "parse_p2_benchmark", + "parse_panel_stage_b_physical_validation", ] diff --git a/dev/benchmarks/frontend_data/parsers/panel_stage_b.py b/dev/benchmarks/frontend_data/parsers/panel_stage_b.py new file mode 100644 index 000000000..8aa096f1e --- /dev/null +++ b/dev/benchmarks/frontend_data/parsers/panel_stage_b.py @@ -0,0 +1,199 @@ +from __future__ import annotations +"""Parse PR #122 Panel Stage-B physical GPU validation evidence.""" + +import hashlib +import json +from pathlib import Path +from typing import Any + +from ..canonical import make_scale_key, make_scale_label + +_PARSER_NAME = "parse_panel_stage_b_physical_validation_v1" +_PARSER_VERSION = "1.0" + + +def _stable_id(kind: str, *parts: object) -> str: + payload = json.dumps(parts, sort_keys=True, separators=(",", ":"), ensure_ascii=False) + return f"{kind}-" + hashlib.sha256(payload.encode("utf-8")).hexdigest()[:16] + + +def _scale(case: dict[str, Any]) -> dict[str, Any]: + n_samples = int(case["n_samples"]) + n_features = int(case["n_features"]) + return { + "scale_key": make_scale_key(n_samples, n_features), + "n_samples": n_samples, + "n_features": n_features, + "label": make_scale_label(n_samples, n_features), + } + + +def _validation(checks: list[str], status: str, filepath: Path) -> dict[str, Any]: + normalized = "pass" if status == "success" else "fail" + return { + "status": normalized, + "checks": [{"metric": metric, "status": normalized} for metric in checks], + "quality": "reported", + "source_file": filepath.name, + } + + +def parse_panel_stage_b_physical_validation( + filepath: Path, env_id: str +) -> tuple[list[dict], list[dict], list[str]]: + """Emit validation-only Panel runs; this source contains no timings.""" + data = json.loads(filepath.read_text(encoding="utf-8")) + warnings: list[str] = [] + + if data.get("schema_status") != "ok": + warnings.append(f"{filepath.name}: source schema_status is not ok") + if data.get("status") != "success": + warnings.append(f"{filepath.name}: physical validation status is not success") + if data.get("protocol", {}).get("timing_collected") is not False: + warnings.append( + f"{filepath.name}: PR122 physical source must remain validation-only" + ) + + source = { + "file": filepath.name, + "date": data.get("source_date", ""), + "parser": _PARSER_NAME, + "parser_version": _PARSER_VERSION, + } + case_catalog = { + case["case_id"]: case for case in data.get("case_catalog", []) + } + runs: list[dict] = [] + model_ids: set[str] = set() + + for backend in ("cupy", "torch"): + backend_result = data.get("backend_results", {}).get(backend, {}) + executed_backend = backend_result.get("executed_backend") + if executed_backend != backend: + warnings.append( + f"{filepath.name}: requested {backend} but executed {executed_backend!r}" + ) + + for case_id, status in backend_result.get("model_cases", {}).items(): + case = case_catalog.get(case_id) + if case is None: + warnings.append(f"{filepath.name}: unknown case {case_id!r}") + continue + model_id = str(case["model_id"]) + model_ids.add(model_id) + scale = _scale(case) + validation = _validation(case.get("checks", []), str(status), filepath) + if executed_backend != backend: + validation["status"] = "fail" + validation["checks"].append( + { + "metric": "executed_backend_matches_requested", + "status": "fail", + } + ) + + runs.append( + { + "run_id": "", + "benchmark_session_id": f"{env_id}-panel-stage-b-pr122", + "env_id": env_id, + "category_ids": ["panel"], + "model_id": model_id, + "case_id": _stable_id( + "case", case_id, case.get("variant"), scale["scale_key"] + ), + "method_config_id": _stable_id( + "method", + "panel-stage-b-physical-validation", + model_id, + case.get("variant"), + ), + "variant": str(case.get("variant") or case_id), + "penalty": None, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": backend, + "scale": scale, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": data.get("git_sha"), + "working_tree_clean": bool(data.get("working_tree_clean")), + }, + "source": dict(source), + "metrics": { + "validation": validation, + "inference": { + "ok": validation["status"] == "pass", + "quality": "reported", + "source_file": filepath.name, + }, + }, + } + ) + + for diagnostic_id, diagnostic in backend_result.get("diagnostics", {}).items(): + balance = "unbalanced" if diagnostic_id.endswith("unbalanced") else "balanced" + n_samples = 49 if balance == "unbalanced" else 54 + scale = { + "scale_key": make_scale_key(n_samples, 2), + "n_samples": n_samples, + "n_features": 2, + "label": make_scale_label(n_samples, 2), + } + status = str(diagnostic.get("status", "failed")) + validation = _validation( + ["hausman_backend_consistency", "backend_provenance"], status, filepath + ) + if executed_backend != backend: + validation["status"] = "fail" + validation["checks"].append( + { + "metric": "executed_backend_matches_requested", + "status": "fail", + } + ) + model_ids.add("PanelOLS") + runs.append( + { + "run_id": "", + "benchmark_session_id": f"{env_id}-panel-stage-b-pr122", + "env_id": env_id, + "category_ids": ["panel"], + "model_id": "PanelOLS", + "case_id": _stable_id("case", diagnostic_id, scale["scale_key"]), + "method_config_id": _stable_id( + "method", "panel-stage-b-physical-validation", "hausman", balance + ), + "variant": f"hausman-{balance}", + "penalty": None, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": backend, + "scale": scale, + "parameters": { + "metric_scope": "physical_validation", + "diagnostic": "hausman", + "applicable": bool(diagnostic.get("applicable")), + "measurement_git_sha": data.get("git_sha"), + "working_tree_clean": bool(data.get("working_tree_clean")), + }, + "source": dict(source), + "metrics": {"validation": validation}, + } + ) + + models = [ + { + "model_id": model_id, + "primary_category_id": "panel", + "category_ids": ["panel"], + "supports_penalty": False, + "supports_inference": True, + } + for model_id in sorted(model_ids) + ] + return runs, models, warnings diff --git a/dev/benchmarks/frontend_data/registry.py b/dev/benchmarks/frontend_data/registry.py index e2c80b2b9..512a73041 100644 --- a/dev/benchmarks/frontend_data/registry.py +++ b/dev/benchmarks/frontend_data/registry.py @@ -22,6 +22,7 @@ parse_new_modules_benchmark, parse_new_modules_with_anova_benchmark, parse_p2_benchmark, + parse_panel_stage_b_physical_validation, ) MINIMUM_DASHBOARD_SOURCE_DATE = date(2026, 6, 1) @@ -56,6 +57,7 @@ "new_modules_benchmark": parse_new_modules_benchmark, "new_modules_with_anova_benchmark": parse_new_modules_with_anova_benchmark, "p2_benchmark": parse_p2_benchmark, + "panel_stage_b_physical_validation": parse_panel_stage_b_physical_validation, } diff --git a/dev/benchmarks/frontend_sources.json b/dev/benchmarks/frontend_sources.json index 2f39177f5..790db1eca 100644 --- a/dev/benchmarks/frontend_sources.json +++ b/dev/benchmarks/frontend_sources.json @@ -19,6 +19,11 @@ "gpu": "Tesla P100-SXM2-16GB", "cpu": "x86_64", "host": "wE6lDe" + }, + "remote-p100-pr122-20260808": { + "label": "Tesla P100 PR #122 Panel Stage B validation — 2026-08-08", + "gpu": "Tesla P100", + "cpu": "x86_64" } }, "frameworks": { @@ -93,6 +98,10 @@ "cv-benchmark-pr116-20260807": { "label": "Cross-validation benchmark after PR #116 repair — 2026-08-07", "env_id": "remote-p100-pr116-20260807" + }, + "panel-stage-b-pr122-20260808": { + "label": "Panel Stage B physical validation — PR #122 — 2026-08-08", + "env_id": "remote-p100-pr122-20260808" } }, "sources": [ @@ -230,6 +239,21 @@ "measurement_git_sha": "e6e4846b06604ed53e65fc9afd9054bd5777098f", "raw_git_sha": "e6e4846b06604ed53e65fc9afd9054bd5777098f", "provenance_note": "Physical PR #116 validation was executed on Tesla P100 from exact numerical implementation head e6e4846b06604ed53e65fc9afd9054bd5777098f. The artifact records that SHA directly; the historical pre-fix P100 source remains registered separately." + }, + { + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "comparison_id": "panel-stage-b-pr122-20260808", + "path": "results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260808.json", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d", + "parser": "panel_stage_b_physical_validation", + "parser_version": "1.0", + "env_id": "remote-p100-pr122-20260808", + "required": true, + "allowed_issue_codes": [], + "source_date": "2026-08-08", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "raw_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "provenance_note": "Correctness/backend-provenance source only. Tesla P100 physical validation passed on the exact clean Stage-B implementation head; no timing was collected, so the frontend must not infer timing or speedup from this source." } ] } diff --git a/dev/tests/test_panel_stage_b_frontend_source.py b/dev/tests/test_panel_stage_b_frontend_source.py new file mode 100644 index 000000000..f5631cf80 --- /dev/null +++ b/dev/tests/test_panel_stage_b_frontend_source.py @@ -0,0 +1,101 @@ +from __future__ import annotations + +import json +import sys +from pathlib import Path + + +REPO_ROOT = Path(__file__).resolve().parents[2] +sys.path.insert(0, str(REPO_ROOT)) + +SOURCE_PATH = ( + REPO_ROOT + / "results" + / "benchmark_frontend_sources" + / "panel_stage_b_pr122_p100_20260808.json" +) +EXPECTED_SHA256 = "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" +SOURCE_ID = "panel-stage-b-pr122-20260808-882892c6e307" + + +def test_pr122_physical_source_contract_and_hash() -> None: + from dev.benchmarks.frontend_data.canonical import source_sha256 + + data = json.loads(SOURCE_PATH.read_text(encoding="utf-8")) + assert source_sha256(SOURCE_PATH) == EXPECTED_SHA256 + assert data["source_schema_version"] == "1.0" + assert data["source_date"] == "2026-08-08" + assert data["git_sha"] == "636988751bcbfad3442d24d3073cdfcd2b3ac637" + assert data["working_tree_clean"] is True + assert data["status"] == "success" + assert data["schema_status"] == "ok" + assert data["validation_tier"] == "remote-full" + assert data["protocol"]["timing_collected"] is False + assert data["backend_times"] == {"numpy": None, "cupy": None, "torch": None} + assert data["compatibility_matrix"]["cupy"]["model_cases"] == "15/15" + assert data["compatibility_matrix"]["torch"]["model_cases"] == "15/15" + assert data["compatibility_matrix"]["cupy"]["cpu_fallback"] is False + assert data["compatibility_matrix"]["torch"]["cpu_fallback"] is False + + +def test_pr122_parser_emits_validation_only_frontend_runs() -> None: + from dev.benchmarks.frontend_data.parsers import ( + parse_panel_stage_b_physical_validation, + ) + + runs, models, warnings = parse_panel_stage_b_physical_validation( + SOURCE_PATH, "remote-p100-pr122-20260808" + ) + + assert warnings == [] + assert len(runs) == 34 + assert len(models) == 6 + assert {run["backend"] for run in runs} == {"cupy", "torch"} + assert {model["model_id"] for model in models} == { + "PooledOLS", + "BetweenOLS", + "FirstDifferenceOLS", + "PanelOLS", + "RandomEffects", + "FamaMacBeth", + } + assert all("timing" not in run["metrics"] for run in runs) + assert all("speedup" not in run["metrics"] for run in runs) + assert all(run["metrics"]["validation"]["status"] == "pass" for run in runs) + assert all( + run["parameters"]["measurement_git_sha"] + == "636988751bcbfad3442d24d3073cdfcd2b3ac637" + for run in runs + ) + assert all(run["parameters"]["working_tree_clean"] is True for run in runs) + + hausman = [run for run in runs if run["parameters"].get("diagnostic") == "hausman"] + assert len(hausman) == 4 + assert all(run["parameters"]["applicable"] is False for run in hausman) + assert all("inference" not in run["metrics"] for run in hausman) + + estimator_runs = [run for run in runs if run not in hausman] + assert len(estimator_runs) == 30 + assert all(run["metrics"]["inference"]["ok"] is True for run in estimator_runs) + + +def test_pr122_parser_is_registered_in_manifest() -> None: + from dev.benchmarks.frontend_data.parsers import ( + parse_panel_stage_b_physical_validation, + ) + from dev.benchmarks.frontend_data.registry import PARSER_FUNCTIONS, load_manifest + + assert ( + PARSER_FUNCTIONS["panel_stage_b_physical_validation"] + is parse_panel_stage_b_physical_validation + ) + manifest = load_manifest(REPO_ROOT) + assert manifest is not None + entry = next(source for source in manifest["sources"] if source["source_id"] == SOURCE_ID) + assert entry["path"] == ( + "results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260808.json" + ) + assert entry["sha256"] == EXPECTED_SHA256 + assert entry["parser"] == "panel_stage_b_physical_validation" + assert entry["parser_version"] == "1.0" + assert entry["measurement_git_sha"] == "636988751bcbfad3442d24d3073cdfcd2b3ac637" diff --git a/results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260808.json b/results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260808.json new file mode 100644 index 000000000..803b53b21 --- /dev/null +++ b/results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260808.json @@ -0,0 +1,371 @@ +{ + "method": "Panel Tier-1 Stage B physical GPU validation", + "source_schema_version": "1.0", + "source_date": "2026-08-08", + "git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true, + "status": "success", + "environment": { + "env_id": "remote-p100-pr122-20260808", + "gpu": "Tesla P100", + "cpu": "x86_64", + "python": "3.9.16", + "packages": { + "cupy": "13.6.0", + "torch": "2.0.0" + }, + "available_backends": [ + "cupy", + "torch" + ] + }, + "protocol": { + "runner": "dev/benchmarks/validate_panel_stage_b_gpu.py", + "runner_schema_version": 2, + "reference_backend": "numpy", + "dtype": "float64", + "timing_collected": false, + "failure_policy": "fail_on_backend_mismatch_or_precision_regression" + }, + "backend_times": { + "numpy": null, + "cupy": null, + "torch": null + }, + "external_baseline": { + "name": "statgpu NumPy reference", + "time": null, + "version": null + }, + "precision_vs_external": {}, + "convergence_status": {}, + "backend_precision": { + "cupy": "pass", + "torch": "pass" + }, + "compatibility_matrix": { + "cupy": { + "model_cases": "15/15", + "diagnostics": "2/2", + "executed_backend": "cupy", + "cpu_fallback": false + }, + "torch": { + "model_cases": "15/15", + "diagnostics": "2/2", + "executed_backend": "torch", + "cpu_fallback": false + } + }, + "cv_matrix": {}, + "inference_matrix": { + "status": "pass", + "fields": [ + "coef", + "bse", + "tvalues", + "pvalues", + "conf_int", + "nobs", + "df_resid" + ], + "reference": "statgpu NumPy", + "reported_precision": "machine-epsilon scale" + }, + "threshold_source": { + "stage_b": "validator-defined backend parity tolerances", + "stage_a_regression": "validator-defined inference parity tolerances" + }, + "objective_scaling": null, + "penalty_scale_mapping": null, + "cpu_vs_external": null, + "gpu_vs_cpu": null, + "crossover_n": null, + "target_scale_source": "correctness-only physical validation; no performance target", + "optimization_notes": [], + "validation_tier": "remote-full", + "schema_status": "ok", + "timing_scope": { + "collected": false, + "reason": "Correctness/backend-provenance validation only; no benchmark timing was measured." + }, + "reproducibility": { + "exact_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true, + "runner": "dev/benchmarks/validate_panel_stage_b_gpu.py" + }, + "uncovered_reasons": [ + "Performance timing was not collected by this correctness-only physical validation and must not be inferred from this artifact.", + "Hausman was consistently inapplicable for the generated balanced and unbalanced validation datasets; applicability consistency, not a fabricated statistic, is recorded." + ], + "case_catalog": [ + { + "case_id": "pooled_balanced", + "model_id": "PooledOLS", + "variant": "balanced", + "n_samples": 54, + "n_features": 2, + "checks": [ + "fit_statistics", + "bp_lm", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + }, + { + "case_id": "pooled_hac_unsorted_balanced", + "model_id": "PooledOLS", + "variant": "balanced-hac-unsorted", + "n_samples": 54, + "n_features": 2, + "checks": [ + "fit_statistics", + "bp_lm", + "diagnostic_covariance", + "stage_a_inference", + "metadata_sort_alignment", + "backend_provenance" + ] + }, + { + "case_id": "between_balanced", + "model_id": "BetweenOLS", + "variant": "balanced", + "n_samples": 54, + "n_features": 2, + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + }, + { + "case_id": "first_difference_balanced", + "model_id": "FirstDifferenceOLS", + "variant": "balanced", + "n_samples": 54, + "n_features": 2, + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + }, + { + "case_id": "panel_entity_balanced", + "model_id": "PanelOLS", + "variant": "entity-fe-balanced", + "n_samples": 54, + "n_features": 2, + "checks": [ + "fit_statistics", + "pooling_f", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + }, + { + "case_id": "random_effects_balanced", + "model_id": "RandomEffects", + "variant": "balanced", + "n_samples": 54, + "n_features": 2, + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + }, + { + "case_id": "fama_macbeth_balanced", + "model_id": "FamaMacBeth", + "variant": "balanced", + "n_samples": 54, + "n_features": 2, + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + }, + { + "case_id": "panel_two_way_balanced", + "model_id": "PanelOLS", + "variant": "two-way-fe-balanced", + "n_samples": 54, + "n_features": 2, + "checks": [ + "fit_statistics", + "pooling_f", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + }, + { + "case_id": "pooled_unbalanced", + "model_id": "PooledOLS", + "variant": "unbalanced", + "n_samples": 49, + "n_features": 2, + "checks": [ + "fit_statistics", + "bp_lm", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + }, + { + "case_id": "pooled_hac_unsorted_unbalanced", + "model_id": "PooledOLS", + "variant": "unbalanced-hac-unsorted", + "n_samples": 49, + "n_features": 2, + "checks": [ + "fit_statistics", + "bp_lm", + "diagnostic_covariance", + "stage_a_inference", + "metadata_sort_alignment", + "backend_provenance" + ] + }, + { + "case_id": "between_unbalanced", + "model_id": "BetweenOLS", + "variant": "unbalanced", + "n_samples": 49, + "n_features": 2, + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + }, + { + "case_id": "first_difference_unbalanced", + "model_id": "FirstDifferenceOLS", + "variant": "unbalanced", + "n_samples": 49, + "n_features": 2, + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + }, + { + "case_id": "panel_entity_unbalanced", + "model_id": "PanelOLS", + "variant": "entity-fe-unbalanced", + "n_samples": 49, + "n_features": 2, + "checks": [ + "fit_statistics", + "pooling_f", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + }, + { + "case_id": "random_effects_unbalanced", + "model_id": "RandomEffects", + "variant": "unbalanced", + "n_samples": 49, + "n_features": 2, + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + }, + { + "case_id": "fama_macbeth_unbalanced", + "model_id": "FamaMacBeth", + "variant": "unbalanced", + "n_samples": 49, + "n_features": 2, + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + } + ], + "backend_results": { + "cupy": { + "status": "success", + "executed_backend": "cupy", + "model_cases": { + "pooled_balanced": "success", + "pooled_hac_unsorted_balanced": "success", + "between_balanced": "success", + "first_difference_balanced": "success", + "panel_entity_balanced": "success", + "random_effects_balanced": "success", + "fama_macbeth_balanced": "success", + "panel_two_way_balanced": "success", + "pooled_unbalanced": "success", + "pooled_hac_unsorted_unbalanced": "success", + "between_unbalanced": "success", + "first_difference_unbalanced": "success", + "panel_entity_unbalanced": "success", + "random_effects_unbalanced": "success", + "fama_macbeth_unbalanced": "success" + }, + "diagnostics": { + "hausman_balanced": { + "status": "success", + "applicable": false + }, + "hausman_unbalanced": { + "status": "success", + "applicable": false + } + } + }, + "torch": { + "status": "success", + "executed_backend": "torch", + "model_cases": { + "pooled_balanced": "success", + "pooled_hac_unsorted_balanced": "success", + "between_balanced": "success", + "first_difference_balanced": "success", + "panel_entity_balanced": "success", + "random_effects_balanced": "success", + "fama_macbeth_balanced": "success", + "panel_two_way_balanced": "success", + "pooled_unbalanced": "success", + "pooled_hac_unsorted_unbalanced": "success", + "between_unbalanced": "success", + "first_difference_unbalanced": "success", + "panel_entity_unbalanced": "success", + "random_effects_unbalanced": "success", + "fama_macbeth_unbalanced": "success" + }, + "diagnostics": { + "hausman_balanced": { + "status": "success", + "applicable": false + }, + "hausman_unbalanced": { + "status": "success", + "applicable": false + } + } + } + } +} From ea139919e8338a836192c902e182e762ddf69e7b Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 14:55:31 +0800 Subject: [PATCH 044/165] test: update benchmark frontend contracts for PR122 source --- .github/workflows/benchmark-frontend.yml | 5 ++- dev/tests/test_benchmark_catalog.py | 10 +++-- dev/tests/test_benchmark_frontend_data.py | 12 +++--- dev/tests/test_benchmark_inventory_v2.py | 10 ++--- dev/tests/test_frontend_domain_coverage.py | 43 ++++++++++++++++++++-- 5 files changed, 62 insertions(+), 18 deletions(-) diff --git a/.github/workflows/benchmark-frontend.yml b/.github/workflows/benchmark-frontend.yml index 1d7a23532..7a6f2593b 100644 --- a/.github/workflows/benchmark-frontend.yml +++ b/.github/workflows/benchmark-frontend.yml @@ -13,6 +13,7 @@ on: - 'dev/tests/test_cv_runner_instrumentation.py' - 'dev/tests/test_frontend_contracts.py' - 'dev/tests/test_frontend_domain_coverage.py' + - 'dev/tests/test_panel_stage_b_frontend_source.py' - 'dev/tests/fixtures/benchmark_frontend/**' - 'frontend/**' - 'docs/assets/benchmarks/**' @@ -29,6 +30,7 @@ on: - 'dev/tests/test_cv_runner_instrumentation.py' - 'dev/tests/test_frontend_contracts.py' - 'dev/tests/test_frontend_domain_coverage.py' + - 'dev/tests/test_panel_stage_b_frontend_source.py' - 'dev/tests/fixtures/benchmark_frontend/**' - 'frontend/**' - 'docs/assets/benchmarks/**' @@ -61,7 +63,8 @@ jobs: dev/tests/test_benchmark_cv_source.py \ dev/tests/test_cv_runner_instrumentation.py \ dev/tests/test_frontend_contracts.py \ - dev/tests/test_frontend_domain_coverage.py -v + dev/tests/test_frontend_domain_coverage.py \ + dev/tests/test_panel_stage_b_frontend_source.py -v - name: Validate generator output run: python dev/benchmarks/generate_benchmark_data.py --check --strict-sources diff --git a/dev/tests/test_benchmark_catalog.py b/dev/tests/test_benchmark_catalog.py index 62cb676e8..0ce0e3eda 100644 --- a/dev/tests/test_benchmark_catalog.py +++ b/dev/tests/test_benchmark_catalog.py @@ -97,6 +97,10 @@ def test_coverage_matrix_is_referentially_complete(coverage_matrix, manifest): "cv-benchmark-20260807-1347184c988d", "cv-benchmark-pr116-20260807-bd8d512adced", ] + assert rows["panel-estimation"]["source_ids"] == [ + "new-modules-20260624-bcbdb676223b", + "panel-stage-b-pr122-20260808-882892c6e307", + ] assert rows["distribution-api"]["issue"] == "#101" assert rows["feature-selection-knockoff"]["issue"] == "#103" assert rows["penalized-coxph"]["issue"] == "#107" @@ -119,9 +123,9 @@ def test_inventory_v2_reconciles_literal_counts( assert inventory["inventory_version"] == "2.0" assert inventory["discovered_json_artifacts"] == len(entries) assert inventory["classified_candidate_sources"] == len(entries) - assert inventory["registered_sources"] == len(manifest["sources"]) == 10 - assert inventory["available_registered_sources"] == 10 - assert inventory["parsed_registered_sources"] == 10 + assert inventory["registered_sources"] == len(manifest["sources"]) == 11 + assert inventory["available_registered_sources"] == 11 + assert inventory["parsed_registered_sources"] == 11 assert inventory["eligible_sources"] == ( inventory["registered_sources"] + inventory["eligible_unregistered_sources"] diff --git a/dev/tests/test_benchmark_frontend_data.py b/dev/tests/test_benchmark_frontend_data.py index d19b94647..968270b91 100644 --- a/dev/tests/test_benchmark_frontend_data.py +++ b/dev/tests/test_benchmark_frontend_data.py @@ -159,7 +159,7 @@ class TestManifestMode: def test_manifest_loads_with_exact_current_sources(self, manifest): assert manifest is not None assert manifest["minimum_source_date"] == "2026-06-01" - assert len(manifest["sources"]) == 10 + assert len(manifest["sources"]) == 11 assert all(source.get("source_date") for source in manifest["sources"]) def test_canonical_generate(self, generator, manifest, results_dir): @@ -174,11 +174,11 @@ def test_canonical_generate(self, generator, manifest, results_dir): assert output["frameworks"] assert output["comparisons"] assert output["meta"]["generation_id"] - assert report["files_seen"] == 10 - assert report["files_parsed"] == 10 - assert inventory["registered_sources"] == 10 - assert inventory["available_sources"] == 10 - assert inventory["parsed_sources"] == 10 + assert report["files_seen"] == 11 + assert report["files_parsed"] == 11 + assert inventory["registered_sources"] == 11 + assert inventory["available_sources"] == 11 + assert inventory["parsed_sources"] == 11 assert not any( run["source"]["source_id"].startswith("transitional:") for run in output["runs"] diff --git a/dev/tests/test_benchmark_inventory_v2.py b/dev/tests/test_benchmark_inventory_v2.py index dc87b98c2..4ee720b8c 100644 --- a/dev/tests/test_benchmark_inventory_v2.py +++ b/dev/tests/test_benchmark_inventory_v2.py @@ -58,7 +58,7 @@ def test_canonical_inventory_v2_publishes_audited_catalog_snapshot() -> None: entry for entry in inventory["catalog_entries"] if entry["classification"] == "registered_canonical" ] - assert len(registered) == inventory["registered_sources"] == 10 + assert len(registered) == inventory["registered_sources"] == 11 assert all(entry["registered"] for entry in registered) @@ -80,13 +80,13 @@ def test_serialized_inventory_omits_legacy_aliases() -> None: assert "eligible_total" not in serialized assert "available_sources" not in serialized assert "parsed_sources" not in serialized - assert serialized["available_registered_sources"] == 10 - assert serialized["parsed_registered_sources"] == 10 + assert serialized["available_registered_sources"] == 11 + assert serialized["parsed_registered_sources"] == 11 # Old Python callers can still read the two non-semantic aliases without # reintroducing those keys into the published JSON contract. - assert inventory["available_sources"] == 10 - assert inventory["parsed_sources"] == 10 + assert inventory["available_sources"] == 11 + assert inventory["parsed_sources"] == 11 def test_modified_repository_manifest_retains_legacy_inventory_contract() -> None: diff --git a/dev/tests/test_frontend_domain_coverage.py b/dev/tests/test_frontend_domain_coverage.py index eab413c7c..bd7b3949b 100644 --- a/dev/tests/test_frontend_domain_coverage.py +++ b/dev/tests/test_frontend_domain_coverage.py @@ -48,7 +48,7 @@ def test_published_categories_have_runs(canonical_output): def test_dashboard_uses_only_june_2026_or_later_sources(canonical_output): output, _, _, manifest = canonical_output assert manifest["minimum_source_date"] == "2026-06-01" - assert len(manifest["sources"]) == 10 + assert len(manifest["sources"]) == 11 manifest_dates = { source["source_id"]: date.fromisoformat(source["source_date"]) @@ -297,6 +297,38 @@ def test_panel_exposes_complete_aligned_scale_matrix(canonical_output): assert {run["source"]["parser_version"] for run in panel_runs} == {"1.4"} +def test_panel_stage_b_physical_validation_is_published_without_timing(canonical_output): + output, _, _, _ = canonical_output + rows = [ + run + for run in output["runs"] + if run["source"]["source_id"] + == "panel-stage-b-pr122-20260808-882892c6e307" + ] + assert len(rows) == 34 + assert {run["backend"] for run in rows} == {"cupy", "torch"} + assert {run["model_id"] for run in rows} == { + "PooledOLS", + "BetweenOLS", + "FirstDifferenceOLS", + "PanelOLS", + "RandomEffects", + "FamaMacBeth", + } + assert all(run["metrics"]["validation"]["status"] == "pass" for run in rows) + assert all("timing" not in run["metrics"] for run in rows) + assert all("speedup" not in run["metrics"] for run in rows) + assert all( + run["parameters"]["measurement_git_sha"] + == "636988751bcbfad3442d24d3073cdfcd2b3ac637" + for run in rows + ) + + hausman = [run for run in rows if run["parameters"].get("diagnostic") == "hausman"] + assert len(hausman) == 4 + assert all(run["parameters"]["applicable"] is False for run in hausman) + + def test_unsupervised_exposes_complete_source_matrix(canonical_output): output, _, _, _ = canonical_output rows = [ @@ -353,8 +385,8 @@ def test_unsupervised_exposes_complete_source_matrix(canonical_output): def test_generated_bundle_has_expected_complete_run_count(canonical_output): output, report, _, _ = canonical_output - assert len(output["runs"]) == 1818 - assert report["runs_generated"] == 1818 + assert len(output["runs"]) == 1852 + assert report["runs_generated"] == 1852 def test_missing_domain_sources_are_manifest_registered(canonical_output): @@ -366,6 +398,7 @@ def test_missing_domain_sources_are_manifest_registered(canonical_output): "unsupervised_benchmark", "new_modules_with_anova_benchmark", "p2_benchmark", + "panel_stage_b_physical_validation", } <= parsers @@ -389,6 +422,10 @@ def test_domain_models_are_present(canonical_output): "KMeans", "PanelOLS", "RandomEffects", + "PooledOLS", + "BetweenOLS", + "FirstDifferenceOLS", + "FamaMacBeth", "GAM", "EmpiricalCovariance", "OneWayANOVA", From d10f44415155a743ff756bb7f5d518e4284fc724 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 15:00:12 +0800 Subject: [PATCH 045/165] docs: link PR122 physical evidence to canonical frontend source --- dev/reviews/pr122_physical_gpu_validation.md | 20 +++++++++++++++----- 1 file changed, 15 insertions(+), 5 deletions(-) diff --git a/dev/reviews/pr122_physical_gpu_validation.md b/dev/reviews/pr122_physical_gpu_validation.md index 0695d987f..554f5e6c8 100644 --- a/dev/reviews/pr122_physical_gpu_validation.md +++ b/dev/reviews/pr122_physical_gpu_validation.md @@ -2,6 +2,14 @@ Validated implementation head: `636988751bcbfad3442d24d3073cdfcd2b3ac637`. +Canonical machine-readable evidence: + +- source: `results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260808.json` +- SHA256: `882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d` +- frontend source id: `panel-stage-b-pr122-20260808-882892c6e307` +- parser: `panel_stage_b_physical_validation` v1.0 +- evidence type: validation/correctness/backend provenance only; no timing or speedup is inferred from this source. + Environment reported by the physical run: - NVIDIA Tesla P100 @@ -11,10 +19,10 @@ Environment reported by the physical run: Top-level artifact contract: -- `schema_version = 2` -- `git_sha = 636988751bcbfad3442d24d3073cdfcd2b3ac637` -- `working_tree_clean = true` -- `status = success` +- `schema_version = 2` in the physical runner output; the normalized frontend source records `runner_schema_version = 2` under its source schema v1.0 wrapper; +- `git_sha = 636988751bcbfad3442d24d3073cdfcd2b3ac637`; +- `working_tree_clean = true`; +- `status = success`. CuPy acceptance: @@ -40,4 +48,6 @@ Stage-B checks passed for the maintained model matrix: Stage-A regression checks also passed for `coef`, `bse`, `tvalues`, `pvalues`, `conf_int`, `nobs`, and `df_resid`. CuPy and Torch results remained within machine-precision-scale differences of the NumPy reference, so the Stage-B integration did not regress the Stage-A coefficient-inference contract. -This record captures the physical acceptance summary supplied for the exact clean implementation head. PR promotion still requires the final hosted/doc-only head to remain green after any evidence-only documentation updates. +The benchmark frontend registers this evidence as 34 validation-only runs: 30 estimator/backend rows plus four Hausman applicability rows. The generated records contain CuPy/Torch backend provenance and validation/inference status but deliberately contain no `metrics.timing` or `metrics.speedup` fields. + +This record captures the physical acceptance summary supplied for the exact clean implementation head. Subsequent PR commits may update evidence, parser, generated frontend assets, tests, or documentation; the physical numerical result remains applicable only while no Stage-B statistical implementation or physical-runner code changes after the validated implementation head. From 3f222f7f7e61acb2e659126d330c4ad86bb25ee1 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 15:00:45 +0800 Subject: [PATCH 046/165] docs: document PR122 validation-only frontend source --- frontend/README.md | 24 ++++++++++++++++-------- 1 file changed, 16 insertions(+), 8 deletions(-) diff --git a/frontend/README.md b/frontend/README.md index fc5305089..f85fd36eb 100644 --- a/frontend/README.md +++ b/frontend/README.md @@ -4,7 +4,7 @@ Interactive benchmark dashboard for statgpu, built with Vite, TypeScript, and EC ## Current coverage -The canonical dashboard is restricted to benchmark sources dated **2026-06-01 or later**. The manifest currently registers **eight sources**, producing **1,774 normalized runs across 36 models**: +The canonical dashboard is restricted to benchmark sources dated **2026-06-01 or later**. The manifest currently registers **11 sources**, producing **1,852 normalized runs across 46 models**: - `p2_benchmark_20260617.json`; - `penalized_glm_perf_20260622.json`; @@ -13,15 +13,18 @@ The canonical dashboard is restricted to benchmark sources dated **2026-06-01 or - `loss_functions_20260623.json`; - `new_modules_full_20260624.json`; - `unsupervised_20260627.json`; -- `ordered_inference_pr74.json`. +- `ordered_inference_pr74.json`; +- `cv_benchmark_20260807.json`; +- `results/pr116_p100/cv_benchmark_pr116_p100.json`; +- `panel_stage_b_pr122_p100_20260808.json`. -Covered categories include penalized GLM and GLM, recent linear models, robust and quantile regression, survival analysis, unsupervised learning, ordered models, nonparametric methods, panel models, covariance estimation, and ANOVA. +Covered categories include penalized GLM and GLM, recent linear models, robust and quantile regression, survival analysis, unsupervised learning, ordered models, nonparametric methods, panel models, covariance estimation, ANOVA, and current cross-validation families. Survival coverage combines the dedicated Efron benchmark with the aligned Breslow rows embedded in `loss_functions_20260623.json`. Breslow contributes five scales, NumPy/CuPy/Torch and statsmodels timings, runner-reported speedups against statsmodels, and CPU/CuPy precision validation. The richer Efron source retains its light-ties and heavy-ties variants. GAM coverage exposes two distinct fixed-lambda pyGAM comparison variants at `1K×3`, `10K×5`, and `100K×10`: the ordinary source comparison and the uniform-knot precision-aligned comparison. Each variant includes NumPy, CuPy, Torch, and pyGAM timing, reported speedup, and prediction-difference validation. Other nonparametric and covariance families remain limited by available source artifacts rather than hidden frontend rows. -Panel coverage exposes both aligned linearmodels scales present in the June 24 source: `10K×10` and `100K×20`. PanelOLS and RandomEffects each include NumPy, CuPy, Torch, and linearmodels timing, runner-reported speedup, and coefficient-relative-error metrics. +Panel coverage has two complementary evidence classes. The June 24 timing source exposes aligned `10K×10` and `100K×20` PanelOLS and RandomEffects comparisons with NumPy, CuPy, Torch, and linearmodels timing, runner-reported speedup, and coefficient-relative-error metrics. PR #122 additionally registers `results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260808.json` (SHA256 `882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d`) as **validation-only** P100 evidence for PooledOLS, BetweenOLS, FirstDifferenceOLS, PanelOLS, RandomEffects, and FamaMacBeth. It contributes 34 CuPy/Torch validation rows covering Stage-B fit statistics/specification diagnostics, backend provenance, and Stage-A coefficient-inference regression. No timing was collected by that physical validator, so these rows deliberately expose neither timing nor speedup metrics. Unsupervised coverage now retains all 131 rows present in the June 27 source rather than selecting one scale per estimator. This includes complete small/medium/large matrices for PCA, KMeans, GaussianMixture, NMF, TruncatedSVD, IncrementalPCA, MiniBatchKMeans, and MiniBatchNMF; both DBSCAN dimensional variants; and every feasible AgglomerativeClustering, UMAP, and t-SNE row. Large input dimensions are labelled from the arrays actually passed to fit, so capped estimators correctly show `100K×50` rather than the uncapped `100K×100` template. @@ -29,7 +32,7 @@ The PR #74 source now contributes all of its inference methods: Ordered Logit/Pr ANOVA coverage includes one-way ANOVA, two-way ANOVA, Welch ANOVA, Tukey HSD, and Bonferroni correction on NumPy, CuPy, and Torch. One-way ANOVA also includes aligned SciPy timing and F-statistic validation rows. -The linear-model category uses the June 2026 squared-error rows from `penalized_glm_perf_20260622.json` and `glm_solver_20260623.json`. April 2026 ElasticNet, LassoCV, comprehensive-validation, Cox package-comparison, and knockoff results are intentionally not registered. +The linear-model category uses the June 2026 squared-error rows from `penalized_glm_perf_20260622.json` and `glm_solver_benchmark_20260623.json`. April 2026 ElasticNet, LassoCV, comprehensive-validation, Cox package-comparison, and knockoff results are intentionally not registered. Current June-or-later sources provide external comparisons through scikit-learn, SciPy, statsmodels, linearmodels, and pyGAM. The feature-selection category remains part of Schema v1.1, but it is intentionally empty until a June 2026-or-later structured benchmark is available. A June distribution report also exists, but it remains outside the dashboard until its rounded Markdown tables are converted or rerun as a structured source with full timing and precision provenance. @@ -38,7 +41,7 @@ Current June-or-later sources provide external comparisons through scikit-learn, - Environment and category navigation. - Progressive filters for model, variant, penalty, solver, scale, backend, and external framework. - Explicit **Focused** and **Full matrix** chart views. -- Timing and speedup charts. +- Timing and speedup charts when those metrics exist for the selected runs. - A sortable and paginated overview table. - Validation, accuracy, inference, prediction, convergence, and selection panels. - Parse-report and source-inventory metadata. @@ -52,6 +55,8 @@ Speedups have two distinct meanings: - **Computed**: reference timing divided by current-run timing. The generated record contains `reference_run_id`. - **Reported by runner**: copied from a benchmark runner that already computed the speedup. These rows carry an `Ⓡ` marker and do not imply frontend recomputation. +Validation-only runs such as PR #122 do not participate in either speedup class because their source contains no timing measurements. + The speedup chart uses a dashed gray 1× parity line with a compact in-chart `1×` badge and `×` axis labels. Runner-reported bars use a subtle border instead of a patterned fill. The global headline card displays only the fastest runner-reported GPU speedup; computed ratios remain available in the chart and raw data for auditing. ## Requirements @@ -88,8 +93,11 @@ The generator automatically uses `dev/benchmarks/frontend_sources.json`. Require python -m pip install -U pytest jsonschema pytest \ dev/tests/test_benchmark_frontend_data.py \ + dev/tests/test_benchmark_catalog.py \ + dev/tests/test_benchmark_inventory_v2.py \ dev/tests/test_frontend_contracts.py \ - dev/tests/test_frontend_domain_coverage.py -v + dev/tests/test_frontend_domain_coverage.py \ + dev/tests/test_panel_stage_b_frontend_source.py -v python dev/benchmarks/generate_benchmark_data.py --check --strict-sources @@ -100,7 +108,7 @@ npx playwright install --with-deps chromium npm run test:e2e ``` -The domain-coverage suite verifies robust/quantile, survival, unsupervised, ordered, nonparametric, panel, covariance, and ANOVA runs. It specifically guards CoxPH Breslow timing/speedup/validation, both complete GAM comparison variants, both aligned Panel scales, all 131 Unsupervised rows and corrected scale labels, all PR #74 inference methods, Focused/Full matrix switching, the dashed 1× parity contract, June 2026 linear-model sources, ANOVA backend/SciPy coverage, speedup-summary semantics, and removal of pre-June framework controls. +The domain-coverage suite verifies robust/quantile, survival, unsupervised, ordered, nonparametric, panel, covariance, and ANOVA runs. It specifically guards CoxPH Breslow timing/speedup/validation, both complete GAM comparison variants, both aligned Panel timing scales, the PR #122 34-row validation-only Panel source, all 131 Unsupervised rows and corrected scale labels, all PR #74 inference methods, Focused/Full matrix switching, the dashed 1× parity contract, June 2026 linear-model sources, ANOVA backend/SciPy coverage, speedup-summary semantics, and removal of pre-June framework controls. ## Production build and staleness From ad70900c626e2dca2bfe68478837182d2d67bca0 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 15:01:24 +0800 Subject: [PATCH 047/165] docs: refresh benchmark dashboard source snapshot --- docs/en/guides/statgpu_benchmark_dashboard.md | 23 ++++++++++++------- 1 file changed, 15 insertions(+), 8 deletions(-) diff --git a/docs/en/guides/statgpu_benchmark_dashboard.md b/docs/en/guides/statgpu_benchmark_dashboard.md index bff682fa7..1ca48ff9e 100644 --- a/docs/en/guides/statgpu_benchmark_dashboard.md +++ b/docs/en/guides/statgpu_benchmark_dashboard.md @@ -6,7 +6,7 @@ The browser is a presentation layer over a generated benchmark bundle. Raw resul ## Current coverage -The canonical manifest is the source of truth for current benchmark inputs, and the deployed inventory is the source of truth for live counts. **Snapshot (2026-08-07):** 9 registered/available/parsed sources produce 1,796 normalized runs, including the first current six-family CV package: +The canonical manifest is the source of truth for current benchmark inputs, and the deployed inventory is the source of truth for live counts. **Snapshot (2026-08-08):** 11 registered/available/parsed sources produce 1,852 normalized runs across 46 models. The current source set includes the post-repair PR #116 CV source and the PR #122 Panel Stage-B physical validation source: | Source | Frontend coverage | |---|---| @@ -19,12 +19,14 @@ The canonical manifest is the source of truth for current benchmark inputs, and | `unsupervised_20260627.json` | Complete source matrix for PCA, clustering, decomposition, mini-batch methods, UMAP, and t-SNE | | `ordered_inference_pr74.json` | Ordered, Quantile, sandwich, oracle, and bootstrap inference configurations | | `cv_benchmark_20260807.json` | RidgeCV, LassoCV, ElasticNetCV, LogisticRegressionCV, PenalizedGLM_CV, and CoxPHCV with explicit backend dispositions | +| `results/pr116_p100/cv_benchmark_pr116_p100.json` | Exact-head P100 CV source after the PR #116 Torch LogisticRegressionCV repair | +| `panel_stage_b_pr122_p100_20260808.json` | Validation-only P100 evidence for Panel Stage-B diagnostics, backend provenance, and Stage-A inference regression | -These sources populate penalized GLM and GLM, recent linear models, robust/quantile regression, survival analysis, unsupervised learning, ordered models, nonparametric methods, panel models, covariance estimation, and ANOVA. +These sources populate penalized GLM and GLM, recent linear models, robust/quantile regression, survival analysis, unsupervised learning, ordered models, nonparametric methods, panel models, covariance estimation, ANOVA, and current CV families. GAM coverage includes `1K×3`, `10K×5`, and `100K×10` for two distinct variants: the ordinary pyGAM comparison and the uniform-knot precision-aligned comparison. Each variant contains statgpu NumPy/CuPy/Torch rows and a pyGAM reference, together with runner-reported speedup and prediction-difference validation. The solver is represented as fixed `lambda=1.0`, matching the source runner rather than incorrectly labelling the work as GCV. -Aligned Panel coverage includes `10K×10` and `100K×20` for both PanelOLS and RandomEffects. Each model/scale contains statgpu NumPy/CuPy/Torch rows and a linearmodels reference, together with runner-reported speedup and coefficient-relative-error metrics. +Panel evidence is intentionally split by measurement purpose. The June 24 timing source includes aligned `10K×10` and `100K×20` PanelOLS and RandomEffects comparisons; each model/scale contains statgpu NumPy/CuPy/Torch rows and a linearmodels reference, together with runner-reported speedup and coefficient-relative-error metrics. PR #122 adds a separate canonical source at `results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260808.json` (SHA256 `882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d`). It records the exact clean implementation head `636988751bcbfad3442d24d3073cdfcd2b3ac637` on Tesla P100 and contributes 34 validation-only CuPy/Torch rows covering PooledOLS, BetweenOLS, FirstDifferenceOLS, PanelOLS, RandomEffects, FamaMacBeth, Stage-B fit/specification diagnostics, backend provenance, and Stage-A coefficient-inference regression. The physical validator did **not** collect timing, so these runs intentionally omit `metrics.timing` and `metrics.speedup`; the frontend must not infer a performance claim from them. Unsupervised coverage retains all 131 source rows. PCA, KMeans, GaussianMixture, NMF, TruncatedSVD, IncrementalPCA, MiniBatchKMeans, and MiniBatchNMF expose every small/medium/large configuration. DBSCAN exposes both 10-dimensional and 50-dimensional variants at all three scales; AgglomerativeClustering, UMAP, and t-SNE expose every scale actually run. Large labels follow the arrays passed to fit, so estimators capped at 50 input features are correctly shown as `100K×50` instead of the uncapped `100K×100` runner template. @@ -32,7 +34,7 @@ The PR #74 source now exposes all of its methods. In addition to Ordered Logit/P ANOVA coverage includes one-way ANOVA, two-way ANOVA, Welch ANOVA, Tukey HSD, and Bonferroni correction at three scales on NumPy, CuPy, and Torch. One-way ANOVA also contains aligned SciPy timing and F-statistic validation rows. -The current bundle should not be interpreted as complete coverage of every implementation in the repository. In particular, the robust source contains CPU Huber and Quantile fit comparisons but no Bisquare, Fair, or robust-loss GPU fit matrix. Ordered scales remain too small to locate a GPU crossover; covariance currently contains only EmpiricalCovariance; Feature Selection has no eligible structured source; and ANOVA has too few synchronization-safe scale points for a precise crossover interval. +The current bundle should not be interpreted as complete coverage of every implementation in the repository. In particular, the robust source contains CPU Huber and Quantile fit comparisons but no Bisquare, Fair, or robust-loss GPU fit matrix. Ordered scales remain too small to locate a GPU crossover; covariance currently contains only EmpiricalCovariance; Feature Selection has no eligible structured source; and ANOVA has too few synchronization-safe scale points for a precise crossover interval. Panel Stage C covariance completion and broader Panel timing remain tracked separately from the PR #122 correctness source. A June distribution benchmark also exists and reports 139/139 SciPy precision checks plus NumPy/CuPy/Torch timings for 15 distributions. It is not yet registered because only a rounded Markdown report is committed, without raw repeats, per-check errors, or a structured category/source contract. It is recorded as a P1 structured-conversion or rerun task rather than being ignored or represented with invented metadata. @@ -84,6 +86,8 @@ The timing chart uses `metrics.timing.fit_time_ms`. Group identity includes comp Focused labels omit repeated scale and Auto/best text. Full-matrix labels use two lines. Both modes use bounded label width and full tooltip text, avoiding a dense diagonal label wall. +Validation-only runs with no `metrics.timing`, including the PR #122 physical Panel source, do not create timing bars. + ### Speedup A value above one means faster than the reference; a value below one is a slowdown. A dashed gray line marks 1× parity, with a compact `1×` badge above the bar area. Horizontal tick labels include the `×` unit. @@ -93,7 +97,7 @@ A value above one means faster than the reference; a value below one is a slowdo Semantic validation checks computed references, positive timings, compatible identities, and numerical agreement with the timing ratio. -The global summary card shows only the fastest runner-reported GPU speedup. Computed timing ratios remain available in the chart and raw data for auditing; the two reference semantics are not mixed into one headline. +The global summary card shows only the fastest runner-reported GPU speedup. Computed timing ratios remain available in the chart and raw data for auditing; the two reference semantics are not mixed into one headline. Validation-only sources without timing are excluded from speedup aggregation. ## Visual theme @@ -115,7 +119,7 @@ Panels appear only when filtered rows contain the corresponding metric group: - **Convergence**: iteration summaries and convergence rates. - **Selection**: precision, recall, FDP, F1, Jaccard, FDR, and selected-set size when a current source exists. -The Inference panel covers Ordered Logit/Probit, Quantile kernel/bootstrap inference, and the restored sandwich/oracle/bootstrap configurations. ANOVA one-way rows expose SciPy-relative F-statistic validation in the Validation panel. +The Inference panel covers Ordered Logit/Probit, Quantile kernel/bootstrap inference, the restored sandwich/oracle/bootstrap configurations, and the PR #122 estimator rows' reported physical inference-pass status. ANOVA one-way rows expose SciPy-relative F-statistic validation in the Validation panel. PR #122 Hausman applicability rows remain validation-only because the generated validation datasets yielded `applicable=false`; the parser does not invent a test statistic. ## Metric provenance @@ -142,8 +146,11 @@ All three files share one `generation_id`. In canonical mode, inventory fields r python -m pip install -U pytest jsonschema pytest \ dev/tests/test_benchmark_frontend_data.py \ + dev/tests/test_benchmark_catalog.py \ + dev/tests/test_benchmark_inventory_v2.py \ dev/tests/test_frontend_contracts.py \ - dev/tests/test_frontend_domain_coverage.py -v + dev/tests/test_frontend_domain_coverage.py \ + dev/tests/test_panel_stage_b_frontend_source.py -v python dev/benchmarks/generate_benchmark_data.py \ --out frontend/public/data/benchmark_data.json \ @@ -166,7 +173,7 @@ npm run test:e2e:production 2. Register SHA256, environment, comparison, parser, allowed issue codes, and `source_date` in `frontend_sources.json`. 3. Ensure `source_date` is on or after the manifest's `minimum_source_date`. 4. Implement or reuse a parser and register it in `registry.py`. -5. Return schema-compliant runs with canonical case/method identities. +5. Return schema-compliant runs with canonical case/method identities. Validation-only sources are allowed, but missing timing/speedup must remain absent rather than inferred. 6. Add parser, date-policy, domain-coverage, and interaction tests. 7. Regenerate the bundle and rebuild deployed assets. From ac4fe636dd448da87849f07ed01451cc85135653 Mon Sep 17 00:00:00 2001 From: TheHiddenObserver Date: Sat, 8 Aug 2026 16:00:10 +0800 Subject: [PATCH 048/165] docs: refresh benchmark frontend data for PR122 --- .../benchmarks/data/benchmark_data.json | 2443 ++++++++++++++++- docs/assets/benchmarks/data/parse_report.json | 8 +- .../benchmarks/data/source_inventory.json | 36 +- frontend/public/data/benchmark_data.json | 2443 ++++++++++++++++- frontend/public/data/parse_report.json | 8 +- frontend/public/data/source_inventory.json | 36 +- 6 files changed, 4926 insertions(+), 48 deletions(-) diff --git a/docs/assets/benchmarks/data/benchmark_data.json b/docs/assets/benchmarks/data/benchmark_data.json index bb083b1af..5f41c08fc 100644 --- a/docs/assets/benchmarks/data/benchmark_data.json +++ b/docs/assets/benchmarks/data/benchmark_data.json @@ -4,7 +4,7 @@ "meta": { "generator": "dev/benchmarks/generate_benchmark_data.py", "git_sha": "deterministic", - "generation_id": "ceac2591d688920101474d09e145c7595e6d9460ce347828b4225139fcd60644" + "generation_id": "9543fdc0b57ceabcb1323c257b4a313e48866439059782263f8a6970b1a0b65d" }, "environments": [ { @@ -27,6 +27,12 @@ "gpu": "Tesla P100-SXM2-16GB", "cpu": "x86_64", "host": "wE6lDe" + }, + { + "env_id": "remote-p100-pr122-20260808", + "label": "Tesla P100 PR #122 Panel Stage B validation — 2026-08-08", + "gpu": "Tesla P100", + "cpu": "x86_64" } ], "categories": [ @@ -110,6 +116,15 @@ "supports_penalty": false, "supports_inference": false }, + { + "model_id": "BetweenOLS", + "primary_category_id": "panel", + "category_ids": [ + "panel" + ], + "supports_penalty": false, + "supports_inference": true + }, { "model_id": "BonferroniCorrection", "primary_category_id": "anova", @@ -165,6 +180,24 @@ "supports_penalty": false, "supports_inference": true }, + { + "model_id": "FamaMacBeth", + "primary_category_id": "panel", + "category_ids": [ + "panel" + ], + "supports_penalty": false, + "supports_inference": true + }, + { + "model_id": "FirstDifferenceOLS", + "primary_category_id": "panel", + "category_ids": [ + "panel" + ], + "supports_penalty": false, + "supports_inference": true + }, { "model_id": "GAM", "primary_category_id": "nonparametric", @@ -382,6 +415,15 @@ "supports_penalty": true, "supports_inference": true }, + { + "model_id": "PooledOLS", + "primary_category_id": "panel", + "category_ids": [ + "panel" + ], + "supports_penalty": false, + "supports_inference": true + }, { "model_id": "QuantileRegression", "primary_category_id": "robust_quantile", @@ -562,6 +604,11 @@ "label": "Covariance and nonparametric benchmark — 2026-06-17", "env_id": "remote-p100" }, + { + "comparison_id": "panel-stage-b-pr122-20260808", + "label": "Panel Stage B physical validation — PR #122 — 2026-08-08", + "env_id": "remote-p100-pr122-20260808" + }, { "comparison_id": "penalized-glm-perf-20260622", "label": "Penalized GLM performance — 2026-06-22", @@ -85192,7 +85239,7 @@ "metrics": { "timing": { "fit_time_ms": 7.204592227935791, - "std_ms": 0.03478300871847091, + "std_ms": 0.03478300871847092, "min_ms": 7.1443915367126465, "max_ms": 7.226705551147461, "sample_count": 3, @@ -85347,7 +85394,7 @@ "metrics": { "timing": { "fit_time_ms": 29.17364239692688, - "std_ms": 0.11058449868330528, + "std_ms": 0.11058449868330526, "min_ms": 29.15489673614502, "max_ms": 29.398292303085327, "sample_count": 3, @@ -87473,7 +87520,7 @@ "metrics": { "timing": { "fit_time_ms": 53.322941064834595, - "std_ms": 0.0964612495050475, + "std_ms": 0.09646124950504749, "min_ms": 53.19675803184509, "max_ms": 53.432852029800415, "sample_count": 3, @@ -87783,7 +87830,7 @@ "metrics": { "timing": { "fit_time_ms": 387.08221912384033, - "std_ms": 1.7942564379041452, + "std_ms": 1.794256437904145, "min_ms": 385.0722312927246, "max_ms": 389.46205377578735, "sample_count": 3, @@ -88093,7 +88140,7 @@ "metrics": { "timing": { "fit_time_ms": 9.013503789901733, - "std_ms": 0.08388103984794355, + "std_ms": 0.08388103984794357, "min_ms": 8.965373039245605, "max_ms": 9.162425994873047, "sample_count": 3, @@ -88403,7 +88450,7 @@ "metrics": { "timing": { "fit_time_ms": 12.376457452774048, - "std_ms": 0.1469539035687877, + "std_ms": 0.14695390356878774, "min_ms": 12.127071619033813, "max_ms": 12.476563453674316, "sample_count": 3, @@ -88868,7 +88915,7 @@ "metrics": { "timing": { "fit_time_ms": 76.48885250091553, - "std_ms": 0.7515277112219284, + "std_ms": 0.7515277112219283, "min_ms": 76.3988196849823, "max_ms": 78.03615927696228, "sample_count": 3, @@ -89334,7 +89381,7 @@ "metrics": { "timing": { "fit_time_ms": 75.77601075172424, - "std_ms": 0.45205802075521384, + "std_ms": 0.4520580207552138, "min_ms": 75.26275515556335, "max_ms": 76.36910676956177, "sample_count": 3, @@ -89491,7 +89538,7 @@ "metrics": { "timing": { "fit_time_ms": 153.40235829353333, - "std_ms": 0.5537958099223218, + "std_ms": 0.5537958099223217, "min_ms": 153.37586402893066, "max_ms": 154.56366539001465, "sample_count": 3, @@ -91201,7 +91248,7 @@ "metrics": { "timing": { "fit_time_ms": 393.74133944511414, - "std_ms": 10.053154619538892, + "std_ms": 10.05315461953889, "min_ms": 372.9921281337738, "max_ms": 394.8514759540558, "sample_count": 3, @@ -91413,6 +91460,2380 @@ } }, "comparison_id": "cv-benchmark-pr116-20260807" + }, + { + "run_id": "5462e1e90a36cd55", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-0df334186e5af228", + "method_config_id": "method-c0fdde15c26f43a5", + "variant": "balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "bp_lm", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "363b731718b94e5c", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-dfd23de8fa23785c", + "method_config_id": "method-e4f7696d4033b5bd", + "variant": "balanced-hac-unsorted", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "bp_lm", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "metadata_sort_alignment", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "9b5cd2eed291b06a", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "BetweenOLS", + "case_id": "case-ef4ada9396e927aa", + "method_config_id": "method-c6458b366c6c5b4b", + "variant": "balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "3c891541f7e11fe9", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "FirstDifferenceOLS", + "case_id": "case-77e21b1b2625849e", + "method_config_id": "method-a891526d2820b20c", + "variant": "balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "f3c1ac064c1fd7a8", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-7505e931c271bead", + "method_config_id": "method-936c0cf8f8c6843c", + "variant": "entity-fe-balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "pooling_f", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "8e3629fb1eac1330", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-f697cc38be66bb5b", + "method_config_id": "method-75395c8069822f63", + "variant": "balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "a86430078e2ff148", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "FamaMacBeth", + "case_id": "case-23b6169b7248b5ff", + "method_config_id": "method-b815058aea2adbef", + "variant": "balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "fe5e2dade2f86161", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-6e32a6271b846410", + "method_config_id": "method-64417e823f34055a", + "variant": "two-way-fe-balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "pooling_f", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "5444a2583a7c811d", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-dbbafa2f82f52516", + "method_config_id": "method-0ef4a02559810006", + "variant": "unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "bp_lm", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "7795cf3edbbd1477", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-3fac3845d997d0be", + "method_config_id": "method-0ce477d0912b1b99", + "variant": "unbalanced-hac-unsorted", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "bp_lm", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "metadata_sort_alignment", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "cb549b4cee7bbbc6", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "BetweenOLS", + "case_id": "case-9319e500c0d05810", + "method_config_id": "method-fd5b0f3282f7b323", + "variant": "unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "ad5287f3107212e9", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "FirstDifferenceOLS", + "case_id": "case-7e6762b4b150ea72", + "method_config_id": "method-dc8c010b9bd69c0b", + "variant": "unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "3741822acd5fa940", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-7a6f0593ba47178d", + "method_config_id": "method-73caf204ad0ce7d3", + "variant": "entity-fe-unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "pooling_f", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "049f251d8724aeba", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-8c5eda16f11a344d", + "method_config_id": "method-2062c9b03141cff2", + "variant": "unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "fbec840dfb634ea5", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "FamaMacBeth", + "case_id": "case-9ae95425684d313a", + "method_config_id": "method-2b49a6a725b5ea3c", + "variant": "unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "c648efed4b988c77", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-4a81e6630ee4a244", + "method_config_id": "method-4ed205ed0ad3db26", + "variant": "hausman-balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "diagnostic": "hausman", + "applicable": false, + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "hausman_backend_consistency", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "764fee13f2e956df", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-528c7a3f7e02b3e3", + "method_config_id": "method-6580ac1c68723cc9", + "variant": "hausman-unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "diagnostic": "hausman", + "applicable": false, + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "hausman_backend_consistency", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "24514a1e0d50d1c1", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-0df334186e5af228", + "method_config_id": "method-c0fdde15c26f43a5", + "variant": "balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "bp_lm", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "54ea0b78a1cb2b3d", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-dfd23de8fa23785c", + "method_config_id": "method-e4f7696d4033b5bd", + "variant": "balanced-hac-unsorted", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "bp_lm", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "metadata_sort_alignment", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "67926bc17240c2e7", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "BetweenOLS", + "case_id": "case-ef4ada9396e927aa", + "method_config_id": "method-c6458b366c6c5b4b", + "variant": "balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "4e4c70589919b97c", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "FirstDifferenceOLS", + "case_id": "case-77e21b1b2625849e", + "method_config_id": "method-a891526d2820b20c", + "variant": "balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "08affb4e86d9815a", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-7505e931c271bead", + "method_config_id": "method-936c0cf8f8c6843c", + "variant": "entity-fe-balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "pooling_f", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "fd8c622bab6bd110", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-f697cc38be66bb5b", + "method_config_id": "method-75395c8069822f63", + "variant": "balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "99edb39a954890dc", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "FamaMacBeth", + "case_id": "case-23b6169b7248b5ff", + "method_config_id": "method-b815058aea2adbef", + "variant": "balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "5250e9b9de8ef523", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-6e32a6271b846410", + "method_config_id": "method-64417e823f34055a", + "variant": "two-way-fe-balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "pooling_f", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "05d209eec2dffe87", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-dbbafa2f82f52516", + "method_config_id": "method-0ef4a02559810006", + "variant": "unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "bp_lm", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "8da271bbeb535d97", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-3fac3845d997d0be", + "method_config_id": "method-0ce477d0912b1b99", + "variant": "unbalanced-hac-unsorted", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "bp_lm", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "metadata_sort_alignment", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "52f52d41c9e144f8", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "BetweenOLS", + "case_id": "case-9319e500c0d05810", + "method_config_id": "method-fd5b0f3282f7b323", + "variant": "unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "9d6e94f4096afe8b", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "FirstDifferenceOLS", + "case_id": "case-7e6762b4b150ea72", + "method_config_id": "method-dc8c010b9bd69c0b", + "variant": "unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "0b6773a279743351", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-7a6f0593ba47178d", + "method_config_id": "method-73caf204ad0ce7d3", + "variant": "entity-fe-unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "pooling_f", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "ae7f621572590cec", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-8c5eda16f11a344d", + "method_config_id": "method-2062c9b03141cff2", + "variant": "unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "dfe4a583f9b1ef12", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "FamaMacBeth", + "case_id": "case-9ae95425684d313a", + "method_config_id": "method-2b49a6a725b5ea3c", + "variant": "unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "0a93708869246e19", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-4a81e6630ee4a244", + "method_config_id": "method-4ed205ed0ad3db26", + "variant": "hausman-balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "diagnostic": "hausman", + "applicable": false, + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "hausman_backend_consistency", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "e20ff6c81af91947", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-528c7a3f7e02b3e3", + "method_config_id": "method-6580ac1c68723cc9", + "variant": "hausman-unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "diagnostic": "hausman", + "applicable": false, + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "hausman_backend_consistency", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" } ] } \ No newline at end of file diff --git a/docs/assets/benchmarks/data/parse_report.json b/docs/assets/benchmarks/data/parse_report.json index 5abc6f0d0..4705a2b3f 100644 --- a/docs/assets/benchmarks/data/parse_report.json +++ b/docs/assets/benchmarks/data/parse_report.json @@ -1,10 +1,10 @@ { "report_version": "2.0", - "files_seen": 10, - "files_parsed": 10, + "files_seen": 11, + "files_parsed": 11, "files_skipped": 0, - "runs_generated": 1818, - "generation_id": "ceac2591d688920101474d09e145c7595e6d9460ce347828b4225139fcd60644", + "runs_generated": 1852, + "generation_id": "9543fdc0b57ceabcb1323c257b4a313e48866439059782263f8a6970b1a0b65d", "issues": [ { "source_id": "glm-solver-20260623-1b6197d94d88", diff --git a/docs/assets/benchmarks/data/source_inventory.json b/docs/assets/benchmarks/data/source_inventory.json index 3a6f459fd..24bfb8227 100644 --- a/docs/assets/benchmarks/data/source_inventory.json +++ b/docs/assets/benchmarks/data/source_inventory.json @@ -1,15 +1,15 @@ { "inventory_version": "2.0", "catalog_version": "2.0", - "catalog_digest": "1de71937d6d994c3ada387018a087e0d1c7b146099853c6ab700f0993f25a5fe", + "catalog_digest": "013c057dfd3e9f8bd4fe529e6b843be2851461b65d215222fa6085aacdbfc049", "coverage_matrix_version": "1.0", - "coverage_matrix_digest": "b9264e98be2d774a9251ff122a36a0acb16ab64217a1ae9bcc1ac2e11599edf0", - "discovered_json_artifacts": 89, - "classified_candidate_sources": 89, - "eligible_sources": 10, - "registered_sources": 10, - "available_registered_sources": 10, - "parsed_registered_sources": 10, + "coverage_matrix_digest": "2fdfa2291fac57c59cb0ec75669380fbfd278b995556b3b18043f7a4e2624360", + "discovered_json_artifacts": 90, + "classified_candidate_sources": 90, + "eligible_sources": 11, + "registered_sources": 11, + "available_registered_sources": 11, + "parsed_registered_sources": 11, "eligible_unregistered_sources": 0, "not_canonical_ready_sources": 42, "historical_or_excluded_sources": 37, @@ -828,6 +828,24 @@ "issue": null, "rule_id": "manifest-registration" }, + { + "path": "results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260808.json", + "artifact_type": "json", + "source_date": "2026-08-08", + "classification": "registered_canonical", + "canonical_eligible": true, + "registered": true, + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "parser": "panel_stage_b_physical_validation", + "parser_version": "1.0", + "provenance_status": "complete", + "timing_protocol_status": "accepted", + "statistical_alignment_status": "accepted", + "reason": "Registered in frontend_sources.json and protected by manifest SHA256.", + "superseded_by": null, + "issue": null, + "rule_id": "manifest-registration" + }, { "path": "results/benchmark_frontend_sources/penalized_cox_trusted_gradient_pr80_20260727.json", "artifact_type": "json", @@ -1627,5 +1645,5 @@ "current_evidence_not_canonical_ready": 2, "partial_canonical": 7 }, - "generation_id": "ceac2591d688920101474d09e145c7595e6d9460ce347828b4225139fcd60644" + "generation_id": "9543fdc0b57ceabcb1323c257b4a313e48866439059782263f8a6970b1a0b65d" } \ No newline at end of file diff --git a/frontend/public/data/benchmark_data.json b/frontend/public/data/benchmark_data.json index bb083b1af..5f41c08fc 100644 --- a/frontend/public/data/benchmark_data.json +++ b/frontend/public/data/benchmark_data.json @@ -4,7 +4,7 @@ "meta": { "generator": "dev/benchmarks/generate_benchmark_data.py", "git_sha": "deterministic", - "generation_id": "ceac2591d688920101474d09e145c7595e6d9460ce347828b4225139fcd60644" + "generation_id": "9543fdc0b57ceabcb1323c257b4a313e48866439059782263f8a6970b1a0b65d" }, "environments": [ { @@ -27,6 +27,12 @@ "gpu": "Tesla P100-SXM2-16GB", "cpu": "x86_64", "host": "wE6lDe" + }, + { + "env_id": "remote-p100-pr122-20260808", + "label": "Tesla P100 PR #122 Panel Stage B validation — 2026-08-08", + "gpu": "Tesla P100", + "cpu": "x86_64" } ], "categories": [ @@ -110,6 +116,15 @@ "supports_penalty": false, "supports_inference": false }, + { + "model_id": "BetweenOLS", + "primary_category_id": "panel", + "category_ids": [ + "panel" + ], + "supports_penalty": false, + "supports_inference": true + }, { "model_id": "BonferroniCorrection", "primary_category_id": "anova", @@ -165,6 +180,24 @@ "supports_penalty": false, "supports_inference": true }, + { + "model_id": "FamaMacBeth", + "primary_category_id": "panel", + "category_ids": [ + "panel" + ], + "supports_penalty": false, + "supports_inference": true + }, + { + "model_id": "FirstDifferenceOLS", + "primary_category_id": "panel", + "category_ids": [ + "panel" + ], + "supports_penalty": false, + "supports_inference": true + }, { "model_id": "GAM", "primary_category_id": "nonparametric", @@ -382,6 +415,15 @@ "supports_penalty": true, "supports_inference": true }, + { + "model_id": "PooledOLS", + "primary_category_id": "panel", + "category_ids": [ + "panel" + ], + "supports_penalty": false, + "supports_inference": true + }, { "model_id": "QuantileRegression", "primary_category_id": "robust_quantile", @@ -562,6 +604,11 @@ "label": "Covariance and nonparametric benchmark — 2026-06-17", "env_id": "remote-p100" }, + { + "comparison_id": "panel-stage-b-pr122-20260808", + "label": "Panel Stage B physical validation — PR #122 — 2026-08-08", + "env_id": "remote-p100-pr122-20260808" + }, { "comparison_id": "penalized-glm-perf-20260622", "label": "Penalized GLM performance — 2026-06-22", @@ -85192,7 +85239,7 @@ "metrics": { "timing": { "fit_time_ms": 7.204592227935791, - "std_ms": 0.03478300871847091, + "std_ms": 0.03478300871847092, "min_ms": 7.1443915367126465, "max_ms": 7.226705551147461, "sample_count": 3, @@ -85347,7 +85394,7 @@ "metrics": { "timing": { "fit_time_ms": 29.17364239692688, - "std_ms": 0.11058449868330528, + "std_ms": 0.11058449868330526, "min_ms": 29.15489673614502, "max_ms": 29.398292303085327, "sample_count": 3, @@ -87473,7 +87520,7 @@ "metrics": { "timing": { "fit_time_ms": 53.322941064834595, - "std_ms": 0.0964612495050475, + "std_ms": 0.09646124950504749, "min_ms": 53.19675803184509, "max_ms": 53.432852029800415, "sample_count": 3, @@ -87783,7 +87830,7 @@ "metrics": { "timing": { "fit_time_ms": 387.08221912384033, - "std_ms": 1.7942564379041452, + "std_ms": 1.794256437904145, "min_ms": 385.0722312927246, "max_ms": 389.46205377578735, "sample_count": 3, @@ -88093,7 +88140,7 @@ "metrics": { "timing": { "fit_time_ms": 9.013503789901733, - "std_ms": 0.08388103984794355, + "std_ms": 0.08388103984794357, "min_ms": 8.965373039245605, "max_ms": 9.162425994873047, "sample_count": 3, @@ -88403,7 +88450,7 @@ "metrics": { "timing": { "fit_time_ms": 12.376457452774048, - "std_ms": 0.1469539035687877, + "std_ms": 0.14695390356878774, "min_ms": 12.127071619033813, "max_ms": 12.476563453674316, "sample_count": 3, @@ -88868,7 +88915,7 @@ "metrics": { "timing": { "fit_time_ms": 76.48885250091553, - "std_ms": 0.7515277112219284, + "std_ms": 0.7515277112219283, "min_ms": 76.3988196849823, "max_ms": 78.03615927696228, "sample_count": 3, @@ -89334,7 +89381,7 @@ "metrics": { "timing": { "fit_time_ms": 75.77601075172424, - "std_ms": 0.45205802075521384, + "std_ms": 0.4520580207552138, "min_ms": 75.26275515556335, "max_ms": 76.36910676956177, "sample_count": 3, @@ -89491,7 +89538,7 @@ "metrics": { "timing": { "fit_time_ms": 153.40235829353333, - "std_ms": 0.5537958099223218, + "std_ms": 0.5537958099223217, "min_ms": 153.37586402893066, "max_ms": 154.56366539001465, "sample_count": 3, @@ -91201,7 +91248,7 @@ "metrics": { "timing": { "fit_time_ms": 393.74133944511414, - "std_ms": 10.053154619538892, + "std_ms": 10.05315461953889, "min_ms": 372.9921281337738, "max_ms": 394.8514759540558, "sample_count": 3, @@ -91413,6 +91460,2380 @@ } }, "comparison_id": "cv-benchmark-pr116-20260807" + }, + { + "run_id": "5462e1e90a36cd55", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-0df334186e5af228", + "method_config_id": "method-c0fdde15c26f43a5", + "variant": "balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "bp_lm", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "363b731718b94e5c", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-dfd23de8fa23785c", + "method_config_id": "method-e4f7696d4033b5bd", + "variant": "balanced-hac-unsorted", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "bp_lm", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "metadata_sort_alignment", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "9b5cd2eed291b06a", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "BetweenOLS", + "case_id": "case-ef4ada9396e927aa", + "method_config_id": "method-c6458b366c6c5b4b", + "variant": "balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "3c891541f7e11fe9", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "FirstDifferenceOLS", + "case_id": "case-77e21b1b2625849e", + "method_config_id": "method-a891526d2820b20c", + "variant": "balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "f3c1ac064c1fd7a8", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-7505e931c271bead", + "method_config_id": "method-936c0cf8f8c6843c", + "variant": "entity-fe-balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "pooling_f", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "8e3629fb1eac1330", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-f697cc38be66bb5b", + "method_config_id": "method-75395c8069822f63", + "variant": "balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "a86430078e2ff148", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "FamaMacBeth", + "case_id": "case-23b6169b7248b5ff", + "method_config_id": "method-b815058aea2adbef", + "variant": "balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "fe5e2dade2f86161", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-6e32a6271b846410", + "method_config_id": "method-64417e823f34055a", + "variant": "two-way-fe-balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "pooling_f", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "5444a2583a7c811d", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-dbbafa2f82f52516", + "method_config_id": "method-0ef4a02559810006", + "variant": "unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "bp_lm", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "7795cf3edbbd1477", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-3fac3845d997d0be", + "method_config_id": "method-0ce477d0912b1b99", + "variant": "unbalanced-hac-unsorted", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "bp_lm", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "metadata_sort_alignment", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "cb549b4cee7bbbc6", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "BetweenOLS", + "case_id": "case-9319e500c0d05810", + "method_config_id": "method-fd5b0f3282f7b323", + "variant": "unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "ad5287f3107212e9", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "FirstDifferenceOLS", + "case_id": "case-7e6762b4b150ea72", + "method_config_id": "method-dc8c010b9bd69c0b", + "variant": "unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "3741822acd5fa940", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-7a6f0593ba47178d", + "method_config_id": "method-73caf204ad0ce7d3", + "variant": "entity-fe-unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "pooling_f", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "049f251d8724aeba", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-8c5eda16f11a344d", + "method_config_id": "method-2062c9b03141cff2", + "variant": "unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "fbec840dfb634ea5", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "FamaMacBeth", + "case_id": "case-9ae95425684d313a", + "method_config_id": "method-2b49a6a725b5ea3c", + "variant": "unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "c648efed4b988c77", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-4a81e6630ee4a244", + "method_config_id": "method-4ed205ed0ad3db26", + "variant": "hausman-balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "diagnostic": "hausman", + "applicable": false, + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "hausman_backend_consistency", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "764fee13f2e956df", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-528c7a3f7e02b3e3", + "method_config_id": "method-6580ac1c68723cc9", + "variant": "hausman-unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "diagnostic": "hausman", + "applicable": false, + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "hausman_backend_consistency", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "24514a1e0d50d1c1", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-0df334186e5af228", + "method_config_id": "method-c0fdde15c26f43a5", + "variant": "balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "bp_lm", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "54ea0b78a1cb2b3d", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-dfd23de8fa23785c", + "method_config_id": "method-e4f7696d4033b5bd", + "variant": "balanced-hac-unsorted", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "bp_lm", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "metadata_sort_alignment", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "67926bc17240c2e7", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "BetweenOLS", + "case_id": "case-ef4ada9396e927aa", + "method_config_id": "method-c6458b366c6c5b4b", + "variant": "balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "4e4c70589919b97c", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "FirstDifferenceOLS", + "case_id": "case-77e21b1b2625849e", + "method_config_id": "method-a891526d2820b20c", + "variant": "balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "08affb4e86d9815a", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-7505e931c271bead", + "method_config_id": "method-936c0cf8f8c6843c", + "variant": "entity-fe-balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "pooling_f", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "fd8c622bab6bd110", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-f697cc38be66bb5b", + "method_config_id": "method-75395c8069822f63", + "variant": "balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "99edb39a954890dc", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "FamaMacBeth", + "case_id": "case-23b6169b7248b5ff", + "method_config_id": "method-b815058aea2adbef", + "variant": "balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "5250e9b9de8ef523", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-6e32a6271b846410", + "method_config_id": "method-64417e823f34055a", + "variant": "two-way-fe-balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "pooling_f", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "05d209eec2dffe87", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-dbbafa2f82f52516", + "method_config_id": "method-0ef4a02559810006", + "variant": "unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "bp_lm", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "8da271bbeb535d97", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-3fac3845d997d0be", + "method_config_id": "method-0ce477d0912b1b99", + "variant": "unbalanced-hac-unsorted", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "bp_lm", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "metadata_sort_alignment", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "52f52d41c9e144f8", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "BetweenOLS", + "case_id": "case-9319e500c0d05810", + "method_config_id": "method-fd5b0f3282f7b323", + "variant": "unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "9d6e94f4096afe8b", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "FirstDifferenceOLS", + "case_id": "case-7e6762b4b150ea72", + "method_config_id": "method-dc8c010b9bd69c0b", + "variant": "unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "0b6773a279743351", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-7a6f0593ba47178d", + "method_config_id": "method-73caf204ad0ce7d3", + "variant": "entity-fe-unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "pooling_f", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "ae7f621572590cec", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-8c5eda16f11a344d", + "method_config_id": "method-2062c9b03141cff2", + "variant": "unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "dfe4a583f9b1ef12", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "FamaMacBeth", + "case_id": "case-9ae95425684d313a", + "method_config_id": "method-2b49a6a725b5ea3c", + "variant": "unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "0a93708869246e19", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-4a81e6630ee4a244", + "method_config_id": "method-4ed205ed0ad3db26", + "variant": "hausman-balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "diagnostic": "hausman", + "applicable": false, + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "hausman_backend_consistency", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "e20ff6c81af91947", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-528c7a3f7e02b3e3", + "method_config_id": "method-6580ac1c68723cc9", + "variant": "hausman-unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "diagnostic": "hausman", + "applicable": false, + "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "original_path": "", + "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "hausman_backend_consistency", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" } ] } \ No newline at end of file diff --git a/frontend/public/data/parse_report.json b/frontend/public/data/parse_report.json index 5abc6f0d0..4705a2b3f 100644 --- a/frontend/public/data/parse_report.json +++ b/frontend/public/data/parse_report.json @@ -1,10 +1,10 @@ { "report_version": "2.0", - "files_seen": 10, - "files_parsed": 10, + "files_seen": 11, + "files_parsed": 11, "files_skipped": 0, - "runs_generated": 1818, - "generation_id": "ceac2591d688920101474d09e145c7595e6d9460ce347828b4225139fcd60644", + "runs_generated": 1852, + "generation_id": "9543fdc0b57ceabcb1323c257b4a313e48866439059782263f8a6970b1a0b65d", "issues": [ { "source_id": "glm-solver-20260623-1b6197d94d88", diff --git a/frontend/public/data/source_inventory.json b/frontend/public/data/source_inventory.json index 3a6f459fd..24bfb8227 100644 --- a/frontend/public/data/source_inventory.json +++ b/frontend/public/data/source_inventory.json @@ -1,15 +1,15 @@ { "inventory_version": "2.0", "catalog_version": "2.0", - "catalog_digest": "1de71937d6d994c3ada387018a087e0d1c7b146099853c6ab700f0993f25a5fe", + "catalog_digest": "013c057dfd3e9f8bd4fe529e6b843be2851461b65d215222fa6085aacdbfc049", "coverage_matrix_version": "1.0", - "coverage_matrix_digest": "b9264e98be2d774a9251ff122a36a0acb16ab64217a1ae9bcc1ac2e11599edf0", - "discovered_json_artifacts": 89, - "classified_candidate_sources": 89, - "eligible_sources": 10, - "registered_sources": 10, - "available_registered_sources": 10, - "parsed_registered_sources": 10, + "coverage_matrix_digest": "2fdfa2291fac57c59cb0ec75669380fbfd278b995556b3b18043f7a4e2624360", + "discovered_json_artifacts": 90, + "classified_candidate_sources": 90, + "eligible_sources": 11, + "registered_sources": 11, + "available_registered_sources": 11, + "parsed_registered_sources": 11, "eligible_unregistered_sources": 0, "not_canonical_ready_sources": 42, "historical_or_excluded_sources": 37, @@ -828,6 +828,24 @@ "issue": null, "rule_id": "manifest-registration" }, + { + "path": "results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260808.json", + "artifact_type": "json", + "source_date": "2026-08-08", + "classification": "registered_canonical", + "canonical_eligible": true, + "registered": true, + "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "parser": "panel_stage_b_physical_validation", + "parser_version": "1.0", + "provenance_status": "complete", + "timing_protocol_status": "accepted", + "statistical_alignment_status": "accepted", + "reason": "Registered in frontend_sources.json and protected by manifest SHA256.", + "superseded_by": null, + "issue": null, + "rule_id": "manifest-registration" + }, { "path": "results/benchmark_frontend_sources/penalized_cox_trusted_gradient_pr80_20260727.json", "artifact_type": "json", @@ -1627,5 +1645,5 @@ "current_evidence_not_canonical_ready": 2, "partial_canonical": 7 }, - "generation_id": "ceac2591d688920101474d09e145c7595e6d9460ce347828b4225139fcd60644" + "generation_id": "9543fdc0b57ceabcb1323c257b4a313e48866439059782263f8a6970b1a0b65d" } \ No newline at end of file From 1760602d2a4c1a1384f8df5cbda72c755fc90425 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 16:11:10 +0800 Subject: [PATCH 049/165] fix: stabilize CV frontend std serialization --- .../frontend_data/parsers/cv_package.py | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/dev/benchmarks/frontend_data/parsers/cv_package.py b/dev/benchmarks/frontend_data/parsers/cv_package.py index 9c8766439..2b3c76df4 100644 --- a/dev/benchmarks/frontend_data/parsers/cv_package.py +++ b/dev/benchmarks/frontend_data/parsers/cv_package.py @@ -30,6 +30,20 @@ def _digest_id(prefix: str, value: Any) -> str: return f"{prefix}-{hashlib.sha256(payload).hexdigest()[:16]}" +def _stable_pstdev_ms(values: list[float]) -> float: + """Return a cross-Python-stable population std for generated JSON. + + ``statistics.pstdev`` may differ by one floating-point ULP across supported + Python runtimes for the same benchmark samples. The dashboard bundle is a + committed deterministic artifact whose generation id hashes the serialized + floats, so retain substantially more precision than the benchmark warrants + while normalizing those runtime-only representation differences. + """ + if len(values) <= 1: + return 0.0 + return round(statistics.pstdev(values), 12) + + def _category_ids(model_id: str) -> list[str]: primary = _PRIMARY_CATEGORY[model_id] if model_id in {"RidgeCV", "LassoCV", "ElasticNetCV", "LogisticRegressionCV"}: @@ -187,7 +201,7 @@ def parse_cv_benchmark( assert convergence is not None assert scores is not None - std_ms = statistics.pstdev(total_samples) if len(total_samples) > 1 else 0.0 + std_ms = _stable_pstdev_ms(total_samples) converged_rate = 1.0 if convergence["final_refit_converged"] else 0.0 validation_status = ( "pass" From a8f0cbd899b6ff15b79aa26f4e7783b75cd3db55 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 16:11:29 +0800 Subject: [PATCH 050/165] test: cover cross-Python CV frontend determinism --- dev/tests/test_frontend_cv_determinism.py | 30 +++++++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 dev/tests/test_frontend_cv_determinism.py diff --git a/dev/tests/test_frontend_cv_determinism.py b/dev/tests/test_frontend_cv_determinism.py new file mode 100644 index 000000000..3e9f71cd9 --- /dev/null +++ b/dev/tests/test_frontend_cv_determinism.py @@ -0,0 +1,30 @@ +from __future__ import annotations + + +def test_cv_std_serialization_normalizes_one_ulp_runtime_drift(monkeypatch) -> None: + """The deterministic frontend bundle must be stable across Python runtimes.""" + from dev.benchmarks.frontend_data.parsers import cv_package + + values = [1.0, 2.0] + + monkeypatch.setattr( + cv_package.statistics, + "pstdev", + lambda _values: 0.03478300871847092, + ) + upper = cv_package._stable_pstdev_ms(values) + + monkeypatch.setattr( + cv_package.statistics, + "pstdev", + lambda _values: 0.03478300871847091, + ) + lower = cv_package._stable_pstdev_ms(values) + + assert upper == lower == 0.034783008718 + + +def test_cv_std_serialization_preserves_single_repeat_zero() -> None: + from dev.benchmarks.frontend_data.parsers.cv_package import _stable_pstdev_ms + + assert _stable_pstdev_ms([12.5]) == 0.0 From 5d86bf8fc0abd6b5d7735bbce631561d71bc5042 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 16:11:53 +0800 Subject: [PATCH 051/165] ci: enforce CV frontend determinism on maintained Python --- .github/workflows/benchmark-frontend.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.github/workflows/benchmark-frontend.yml b/.github/workflows/benchmark-frontend.yml index 7a6f2593b..683318920 100644 --- a/.github/workflows/benchmark-frontend.yml +++ b/.github/workflows/benchmark-frontend.yml @@ -12,6 +12,7 @@ on: - 'dev/tests/test_benchmark_cv_source.py' - 'dev/tests/test_cv_runner_instrumentation.py' - 'dev/tests/test_frontend_contracts.py' + - 'dev/tests/test_frontend_cv_determinism.py' - 'dev/tests/test_frontend_domain_coverage.py' - 'dev/tests/test_panel_stage_b_frontend_source.py' - 'dev/tests/fixtures/benchmark_frontend/**' @@ -29,6 +30,7 @@ on: - 'dev/tests/test_benchmark_cv_source.py' - 'dev/tests/test_cv_runner_instrumentation.py' - 'dev/tests/test_frontend_contracts.py' + - 'dev/tests/test_frontend_cv_determinism.py' - 'dev/tests/test_frontend_domain_coverage.py' - 'dev/tests/test_panel_stage_b_frontend_source.py' - 'dev/tests/fixtures/benchmark_frontend/**' @@ -63,6 +65,7 @@ jobs: dev/tests/test_benchmark_cv_source.py \ dev/tests/test_cv_runner_instrumentation.py \ dev/tests/test_frontend_contracts.py \ + dev/tests/test_frontend_cv_determinism.py \ dev/tests/test_frontend_domain_coverage.py \ dev/tests/test_panel_stage_b_frontend_source.py -v - name: Validate generator output From 65169e024f1913bb46b7a4adc9838a790e28ab41 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 16:16:32 +0800 Subject: [PATCH 052/165] test: lock real CV std determinism across Python --- dev/tests/test_frontend_cv_determinism.py | 25 +++++++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/dev/tests/test_frontend_cv_determinism.py b/dev/tests/test_frontend_cv_determinism.py index 3e9f71cd9..028331194 100644 --- a/dev/tests/test_frontend_cv_determinism.py +++ b/dev/tests/test_frontend_cv_determinism.py @@ -1,5 +1,10 @@ from __future__ import annotations +from pathlib import Path + + +REPO_ROOT = Path(__file__).resolve().parents[2] + def test_cv_std_serialization_normalizes_one_ulp_runtime_drift(monkeypatch) -> None: """The deterministic frontend bundle must be stable across Python runtimes.""" @@ -28,3 +33,23 @@ def test_cv_std_serialization_preserves_single_repeat_zero() -> None: from dev.benchmarks.frontend_data.parsers.cv_package import _stable_pstdev_ms assert _stable_pstdev_ms([12.5]) == 0.0 + + +def test_pr116_sensitive_cv_row_has_stable_canonical_std() -> None: + """Exercise the real row that previously drifted by one ULP on 3.9/3.11.""" + from dev.benchmarks.frontend_data.parsers.cv_package import parse_cv_benchmark + + source = REPO_ROOT / "results" / "pr116_p100" / "cv_benchmark_pr116_p100.json" + runs, _models, warnings = parse_cv_benchmark( + source, "remote-p100-pr116-20260807" + ) + + assert warnings == [] + ridge_numpy = next( + run + for run in runs + if run["model_id"] == "RidgeCV" + and run["framework"] == "statgpu" + and run["backend"] == "numpy" + ) + assert ridge_numpy["metrics"]["timing"]["std_ms"] == 0.083881039848 From 038ee3d42510d5afedf795c9f77005969b439283 Mon Sep 17 00:00:00 2001 From: TheHiddenObserver Date: Sat, 8 Aug 2026 16:29:24 +0800 Subject: [PATCH 053/165] docs: regenerate benchmark frontend after stable CV std --- .../benchmarks/data/benchmark_data.json | 88 +++++++++---------- docs/assets/benchmarks/data/parse_report.json | 2 +- .../benchmarks/data/source_inventory.json | 2 +- frontend/public/data/benchmark_data.json | 88 +++++++++---------- frontend/public/data/parse_report.json | 2 +- frontend/public/data/source_inventory.json | 2 +- 6 files changed, 92 insertions(+), 92 deletions(-) diff --git a/docs/assets/benchmarks/data/benchmark_data.json b/docs/assets/benchmarks/data/benchmark_data.json index 5f41c08fc..be30d0b1a 100644 --- a/docs/assets/benchmarks/data/benchmark_data.json +++ b/docs/assets/benchmarks/data/benchmark_data.json @@ -4,7 +4,7 @@ "meta": { "generator": "dev/benchmarks/generate_benchmark_data.py", "git_sha": "deterministic", - "generation_id": "9543fdc0b57ceabcb1323c257b4a313e48866439059782263f8a6970b1a0b65d" + "generation_id": "820a294b2b6fd58f6c1384b5ffad602f20168dc30102f93a49895e97fb0003dc" }, "environments": [ { @@ -84774,7 +84774,7 @@ "metrics": { "timing": { "fit_time_ms": 9.062319993972778, - "std_ms": 0.011520549774405635, + "std_ms": 0.011520549774, "min_ms": 9.062081575393677, "max_ms": 9.086638689041138, "sample_count": 3, @@ -84929,7 +84929,7 @@ "metrics": { "timing": { "fit_time_ms": 17.41701364517212, - "std_ms": 0.10901293932213849, + "std_ms": 0.109012939322, "min_ms": 17.355382442474365, "max_ms": 17.611205577850342, "sample_count": 3, @@ -85084,7 +85084,7 @@ "metrics": { "timing": { "fit_time_ms": 12.491881847381592, - "std_ms": 0.10357847916711392, + "std_ms": 0.103578479167, "min_ms": 12.459933757781982, "max_ms": 12.69388198852539, "sample_count": 3, @@ -85239,7 +85239,7 @@ "metrics": { "timing": { "fit_time_ms": 7.204592227935791, - "std_ms": 0.03478300871847092, + "std_ms": 0.034783008718, "min_ms": 7.1443915367126465, "max_ms": 7.226705551147461, "sample_count": 3, @@ -85394,7 +85394,7 @@ "metrics": { "timing": { "fit_time_ms": 29.17364239692688, - "std_ms": 0.11058449868330526, + "std_ms": 0.110584498683, "min_ms": 29.15489673614502, "max_ms": 29.398292303085327, "sample_count": 3, @@ -85549,7 +85549,7 @@ "metrics": { "timing": { "fit_time_ms": 76.099693775177, - "std_ms": 0.15514420258897654, + "std_ms": 0.155144202589, "min_ms": 75.85901021957397, "max_ms": 76.23404264450073, "sample_count": 3, @@ -85704,7 +85704,7 @@ "metrics": { "timing": { "fit_time_ms": 34.79743003845215, - "std_ms": 0.08212314243487934, + "std_ms": 0.082123142435, "min_ms": 34.72268581390381, "max_ms": 34.921795129776, "sample_count": 3, @@ -85859,7 +85859,7 @@ "metrics": { "timing": { "fit_time_ms": 7.392674684524536, - "std_ms": 0.06373652588749994, + "std_ms": 0.063736525887, "min_ms": 7.343053817749023, "max_ms": 7.496058940887451, "sample_count": 3, @@ -86015,7 +86015,7 @@ "metrics": { "timing": { "fit_time_ms": 76.40200853347778, - "std_ms": 0.12667643292286518, + "std_ms": 0.126676432923, "min_ms": 76.32750272750854, "max_ms": 76.62561535835266, "sample_count": 3, @@ -86172,7 +86172,7 @@ "metrics": { "timing": { "fit_time_ms": 153.78409624099731, - "std_ms": 1.2051632389990876, + "std_ms": 1.205163238999, "min_ms": 151.39129757881165, "max_ms": 154.0849506855011, "sample_count": 3, @@ -86329,7 +86329,7 @@ "metrics": { "timing": { "fit_time_ms": 122.1560537815094, - "std_ms": 1.2313895375387158, + "std_ms": 1.231389537539, "min_ms": 122.06673622131348, "max_ms": 124.722421169281, "sample_count": 3, @@ -86486,7 +86486,7 @@ "metrics": { "timing": { "fit_time_ms": 7.413893938064575, - "std_ms": 0.03394906482522582, + "std_ms": 0.033949064825, "min_ms": 7.350414991378784, "max_ms": 7.428675889968872, "sample_count": 3, @@ -86642,7 +86642,7 @@ "metrics": { "timing": { "fit_time_ms": 50.83748698234558, - "std_ms": 0.5573683115942412, + "std_ms": 0.557368311594, "min_ms": 50.72379112243652, "max_ms": 51.95888876914978, "sample_count": 3, @@ -86797,7 +86797,7 @@ "metrics": { "timing": { "fit_time_ms": 103.54551672935486, - "std_ms": 0.43010181393284636, + "std_ms": 0.430101813933, "min_ms": 102.88560390472412, "max_ms": 103.92677783966064, "sample_count": 3, @@ -87055,7 +87055,7 @@ "metrics": { "timing": { "fit_time_ms": 32.809287309646606, - "std_ms": 0.22101482164439643, + "std_ms": 0.221014821644, "min_ms": 32.615602016448975, "max_ms": 33.15025568008423, "sample_count": 3, @@ -87210,7 +87210,7 @@ "metrics": { "timing": { "fit_time_ms": 5.704343318939209, - "std_ms": 0.05382879156628554, + "std_ms": 0.053828791566, "min_ms": 5.664348602294922, "max_ms": 5.793154239654541, "sample_count": 3, @@ -87365,7 +87365,7 @@ "metrics": { "timing": { "fit_time_ms": 79.3997049331665, - "std_ms": 0.2710391095246946, + "std_ms": 0.271039109525, "min_ms": 79.18986678123474, "max_ms": 79.8402726650238, "sample_count": 3, @@ -87520,7 +87520,7 @@ "metrics": { "timing": { "fit_time_ms": 53.322941064834595, - "std_ms": 0.09646124950504749, + "std_ms": 0.096461249505, "min_ms": 53.19675803184509, "max_ms": 53.432852029800415, "sample_count": 3, @@ -87675,7 +87675,7 @@ "metrics": { "timing": { "fit_time_ms": 367.21765995025635, - "std_ms": 1.2007614908480113, + "std_ms": 1.200761490848, "min_ms": 367.20117926597595, "max_ms": 369.7565793991089, "sample_count": 3, @@ -87830,7 +87830,7 @@ "metrics": { "timing": { "fit_time_ms": 387.08221912384033, - "std_ms": 1.794256437904145, + "std_ms": 1.794256437904, "min_ms": 385.0722312927246, "max_ms": 389.46205377578735, "sample_count": 3, @@ -87985,7 +87985,7 @@ "metrics": { "timing": { "fit_time_ms": 226.59814357757568, - "std_ms": 1.4370176592588964, + "std_ms": 1.437017659259, "min_ms": 225.08418560028076, "max_ms": 228.59317064285278, "sample_count": 3, @@ -88140,7 +88140,7 @@ "metrics": { "timing": { "fit_time_ms": 9.013503789901733, - "std_ms": 0.08388103984794357, + "std_ms": 0.083881039848, "min_ms": 8.965373039245605, "max_ms": 9.162425994873047, "sample_count": 3, @@ -88295,7 +88295,7 @@ "metrics": { "timing": { "fit_time_ms": 17.37356185913086, - "std_ms": 0.1751727379638956, + "std_ms": 0.175172737964, "min_ms": 17.317146062850952, "max_ms": 17.713725566864014, "sample_count": 3, @@ -88450,7 +88450,7 @@ "metrics": { "timing": { "fit_time_ms": 12.376457452774048, - "std_ms": 0.14695390356878774, + "std_ms": 0.146953903569, "min_ms": 12.127071619033813, "max_ms": 12.476563453674316, "sample_count": 3, @@ -88605,7 +88605,7 @@ "metrics": { "timing": { "fit_time_ms": 7.113069295883179, - "std_ms": 0.022110917652291093, + "std_ms": 0.022110917652, "min_ms": 7.089287042617798, "max_ms": 7.1433186531066895, "sample_count": 3, @@ -88760,7 +88760,7 @@ "metrics": { "timing": { "fit_time_ms": 29.22457456588745, - "std_ms": 0.07344943972222218, + "std_ms": 0.073449439722, "min_ms": 29.094338417053223, "max_ms": 29.266953468322754, "sample_count": 3, @@ -88915,7 +88915,7 @@ "metrics": { "timing": { "fit_time_ms": 76.48885250091553, - "std_ms": 0.7515277112219283, + "std_ms": 0.751527711222, "min_ms": 76.3988196849823, "max_ms": 78.03615927696228, "sample_count": 3, @@ -89070,7 +89070,7 @@ "metrics": { "timing": { "fit_time_ms": 34.95398163795471, - "std_ms": 0.08122915143822747, + "std_ms": 0.081229151438, "min_ms": 34.94828939437866, "max_ms": 35.12337803840637, "sample_count": 3, @@ -89225,7 +89225,7 @@ "metrics": { "timing": { "fit_time_ms": 7.375836372375488, - "std_ms": 0.2661149489547812, + "std_ms": 0.266114948955, "min_ms": 7.340103387832642, "max_ms": 7.92163610458374, "sample_count": 3, @@ -89381,7 +89381,7 @@ "metrics": { "timing": { "fit_time_ms": 75.77601075172424, - "std_ms": 0.4520580207552138, + "std_ms": 0.452058020755, "min_ms": 75.26275515556335, "max_ms": 76.36910676956177, "sample_count": 3, @@ -89538,7 +89538,7 @@ "metrics": { "timing": { "fit_time_ms": 153.40235829353333, - "std_ms": 0.5537958099223217, + "std_ms": 0.553795809922, "min_ms": 153.37586402893066, "max_ms": 154.56366539001465, "sample_count": 3, @@ -89695,7 +89695,7 @@ "metrics": { "timing": { "fit_time_ms": 121.93247675895691, - "std_ms": 0.2863016881758537, + "std_ms": 0.286301688176, "min_ms": 121.55237793922424, "max_ms": 122.25282192230225, "sample_count": 3, @@ -89852,7 +89852,7 @@ "metrics": { "timing": { "fit_time_ms": 7.36507773399353, - "std_ms": 0.0928811561208376, + "std_ms": 0.092881156121, "min_ms": 7.2509050369262695, "max_ms": 7.4784159660339355, "sample_count": 3, @@ -90008,7 +90008,7 @@ "metrics": { "timing": { "fit_time_ms": 51.06106400489807, - "std_ms": 0.12425235011605137, + "std_ms": 0.124252350116, "min_ms": 50.835102796554565, "max_ms": 51.12466216087341, "sample_count": 3, @@ -90163,7 +90163,7 @@ "metrics": { "timing": { "fit_time_ms": 95.80263495445251, - "std_ms": 3.1773095837367222, + "std_ms": 3.177309583737, "min_ms": 89.1546905040741, "max_ms": 95.98329663276672, "sample_count": 3, @@ -90318,7 +90318,7 @@ "metrics": { "timing": { "fit_time_ms": 49.2972731590271, - "std_ms": 2.079922258152906, + "std_ms": 2.079922258153, "min_ms": 48.696696758270264, "max_ms": 53.378403186798096, "sample_count": 3, @@ -90473,7 +90473,7 @@ "metrics": { "timing": { "fit_time_ms": 32.66507387161255, - "std_ms": 0.16058180541689593, + "std_ms": 0.160581805417, "min_ms": 32.47341513633728, "max_ms": 32.866716384887695, "sample_count": 3, @@ -90628,7 +90628,7 @@ "metrics": { "timing": { "fit_time_ms": 5.652785301208496, - "std_ms": 0.0647337375076041, + "std_ms": 0.064733737508, "min_ms": 5.633354187011719, "max_ms": 5.779355764389038, "sample_count": 3, @@ -90783,7 +90783,7 @@ "metrics": { "timing": { "fit_time_ms": 79.96299862861633, - "std_ms": 0.3447674872577324, + "std_ms": 0.344767487258, "min_ms": 79.8010528087616, "max_ms": 80.5998146533966, "sample_count": 3, @@ -90938,7 +90938,7 @@ "metrics": { "timing": { "fit_time_ms": 53.66373062133789, - "std_ms": 0.07744715297714648, + "std_ms": 0.077447152977, "min_ms": 53.63589525222778, "max_ms": 53.81232500076294, "sample_count": 3, @@ -91093,7 +91093,7 @@ "metrics": { "timing": { "fit_time_ms": 368.74711513519287, - "std_ms": 1.0174916822778004, + "std_ms": 1.017491682278, "min_ms": 367.16771125793457, "max_ms": 369.62711811065674, "sample_count": 3, @@ -91248,7 +91248,7 @@ "metrics": { "timing": { "fit_time_ms": 393.74133944511414, - "std_ms": 10.05315461953889, + "std_ms": 10.053154619539, "min_ms": 372.9921281337738, "max_ms": 394.8514759540558, "sample_count": 3, @@ -91403,7 +91403,7 @@ "metrics": { "timing": { "fit_time_ms": 229.87377643585205, - "std_ms": 0.8445346932663552, + "std_ms": 0.844534693266, "min_ms": 229.26145792007446, "max_ms": 231.27886652946472, "sample_count": 3, diff --git a/docs/assets/benchmarks/data/parse_report.json b/docs/assets/benchmarks/data/parse_report.json index 4705a2b3f..af05c2ebc 100644 --- a/docs/assets/benchmarks/data/parse_report.json +++ b/docs/assets/benchmarks/data/parse_report.json @@ -4,7 +4,7 @@ "files_parsed": 11, "files_skipped": 0, "runs_generated": 1852, - "generation_id": "9543fdc0b57ceabcb1323c257b4a313e48866439059782263f8a6970b1a0b65d", + "generation_id": "820a294b2b6fd58f6c1384b5ffad602f20168dc30102f93a49895e97fb0003dc", "issues": [ { "source_id": "glm-solver-20260623-1b6197d94d88", diff --git a/docs/assets/benchmarks/data/source_inventory.json b/docs/assets/benchmarks/data/source_inventory.json index 24bfb8227..322080ace 100644 --- a/docs/assets/benchmarks/data/source_inventory.json +++ b/docs/assets/benchmarks/data/source_inventory.json @@ -1645,5 +1645,5 @@ "current_evidence_not_canonical_ready": 2, "partial_canonical": 7 }, - "generation_id": "9543fdc0b57ceabcb1323c257b4a313e48866439059782263f8a6970b1a0b65d" + "generation_id": "820a294b2b6fd58f6c1384b5ffad602f20168dc30102f93a49895e97fb0003dc" } \ No newline at end of file diff --git a/frontend/public/data/benchmark_data.json b/frontend/public/data/benchmark_data.json index 5f41c08fc..be30d0b1a 100644 --- a/frontend/public/data/benchmark_data.json +++ b/frontend/public/data/benchmark_data.json @@ -4,7 +4,7 @@ "meta": { "generator": "dev/benchmarks/generate_benchmark_data.py", "git_sha": "deterministic", - "generation_id": "9543fdc0b57ceabcb1323c257b4a313e48866439059782263f8a6970b1a0b65d" + "generation_id": "820a294b2b6fd58f6c1384b5ffad602f20168dc30102f93a49895e97fb0003dc" }, "environments": [ { @@ -84774,7 +84774,7 @@ "metrics": { "timing": { "fit_time_ms": 9.062319993972778, - "std_ms": 0.011520549774405635, + "std_ms": 0.011520549774, "min_ms": 9.062081575393677, "max_ms": 9.086638689041138, "sample_count": 3, @@ -84929,7 +84929,7 @@ "metrics": { "timing": { "fit_time_ms": 17.41701364517212, - "std_ms": 0.10901293932213849, + "std_ms": 0.109012939322, "min_ms": 17.355382442474365, "max_ms": 17.611205577850342, "sample_count": 3, @@ -85084,7 +85084,7 @@ "metrics": { "timing": { "fit_time_ms": 12.491881847381592, - "std_ms": 0.10357847916711392, + "std_ms": 0.103578479167, "min_ms": 12.459933757781982, "max_ms": 12.69388198852539, "sample_count": 3, @@ -85239,7 +85239,7 @@ "metrics": { "timing": { "fit_time_ms": 7.204592227935791, - "std_ms": 0.03478300871847092, + "std_ms": 0.034783008718, "min_ms": 7.1443915367126465, "max_ms": 7.226705551147461, "sample_count": 3, @@ -85394,7 +85394,7 @@ "metrics": { "timing": { "fit_time_ms": 29.17364239692688, - "std_ms": 0.11058449868330526, + "std_ms": 0.110584498683, "min_ms": 29.15489673614502, "max_ms": 29.398292303085327, "sample_count": 3, @@ -85549,7 +85549,7 @@ "metrics": { "timing": { "fit_time_ms": 76.099693775177, - "std_ms": 0.15514420258897654, + "std_ms": 0.155144202589, "min_ms": 75.85901021957397, "max_ms": 76.23404264450073, "sample_count": 3, @@ -85704,7 +85704,7 @@ "metrics": { "timing": { "fit_time_ms": 34.79743003845215, - "std_ms": 0.08212314243487934, + "std_ms": 0.082123142435, "min_ms": 34.72268581390381, "max_ms": 34.921795129776, "sample_count": 3, @@ -85859,7 +85859,7 @@ "metrics": { "timing": { "fit_time_ms": 7.392674684524536, - "std_ms": 0.06373652588749994, + "std_ms": 0.063736525887, "min_ms": 7.343053817749023, "max_ms": 7.496058940887451, "sample_count": 3, @@ -86015,7 +86015,7 @@ "metrics": { "timing": { "fit_time_ms": 76.40200853347778, - "std_ms": 0.12667643292286518, + "std_ms": 0.126676432923, "min_ms": 76.32750272750854, "max_ms": 76.62561535835266, "sample_count": 3, @@ -86172,7 +86172,7 @@ "metrics": { "timing": { "fit_time_ms": 153.78409624099731, - "std_ms": 1.2051632389990876, + "std_ms": 1.205163238999, "min_ms": 151.39129757881165, "max_ms": 154.0849506855011, "sample_count": 3, @@ -86329,7 +86329,7 @@ "metrics": { "timing": { "fit_time_ms": 122.1560537815094, - "std_ms": 1.2313895375387158, + "std_ms": 1.231389537539, "min_ms": 122.06673622131348, "max_ms": 124.722421169281, "sample_count": 3, @@ -86486,7 +86486,7 @@ "metrics": { "timing": { "fit_time_ms": 7.413893938064575, - "std_ms": 0.03394906482522582, + "std_ms": 0.033949064825, "min_ms": 7.350414991378784, "max_ms": 7.428675889968872, "sample_count": 3, @@ -86642,7 +86642,7 @@ "metrics": { "timing": { "fit_time_ms": 50.83748698234558, - "std_ms": 0.5573683115942412, + "std_ms": 0.557368311594, "min_ms": 50.72379112243652, "max_ms": 51.95888876914978, "sample_count": 3, @@ -86797,7 +86797,7 @@ "metrics": { "timing": { "fit_time_ms": 103.54551672935486, - "std_ms": 0.43010181393284636, + "std_ms": 0.430101813933, "min_ms": 102.88560390472412, "max_ms": 103.92677783966064, "sample_count": 3, @@ -87055,7 +87055,7 @@ "metrics": { "timing": { "fit_time_ms": 32.809287309646606, - "std_ms": 0.22101482164439643, + "std_ms": 0.221014821644, "min_ms": 32.615602016448975, "max_ms": 33.15025568008423, "sample_count": 3, @@ -87210,7 +87210,7 @@ "metrics": { "timing": { "fit_time_ms": 5.704343318939209, - "std_ms": 0.05382879156628554, + "std_ms": 0.053828791566, "min_ms": 5.664348602294922, "max_ms": 5.793154239654541, "sample_count": 3, @@ -87365,7 +87365,7 @@ "metrics": { "timing": { "fit_time_ms": 79.3997049331665, - "std_ms": 0.2710391095246946, + "std_ms": 0.271039109525, "min_ms": 79.18986678123474, "max_ms": 79.8402726650238, "sample_count": 3, @@ -87520,7 +87520,7 @@ "metrics": { "timing": { "fit_time_ms": 53.322941064834595, - "std_ms": 0.09646124950504749, + "std_ms": 0.096461249505, "min_ms": 53.19675803184509, "max_ms": 53.432852029800415, "sample_count": 3, @@ -87675,7 +87675,7 @@ "metrics": { "timing": { "fit_time_ms": 367.21765995025635, - "std_ms": 1.2007614908480113, + "std_ms": 1.200761490848, "min_ms": 367.20117926597595, "max_ms": 369.7565793991089, "sample_count": 3, @@ -87830,7 +87830,7 @@ "metrics": { "timing": { "fit_time_ms": 387.08221912384033, - "std_ms": 1.794256437904145, + "std_ms": 1.794256437904, "min_ms": 385.0722312927246, "max_ms": 389.46205377578735, "sample_count": 3, @@ -87985,7 +87985,7 @@ "metrics": { "timing": { "fit_time_ms": 226.59814357757568, - "std_ms": 1.4370176592588964, + "std_ms": 1.437017659259, "min_ms": 225.08418560028076, "max_ms": 228.59317064285278, "sample_count": 3, @@ -88140,7 +88140,7 @@ "metrics": { "timing": { "fit_time_ms": 9.013503789901733, - "std_ms": 0.08388103984794357, + "std_ms": 0.083881039848, "min_ms": 8.965373039245605, "max_ms": 9.162425994873047, "sample_count": 3, @@ -88295,7 +88295,7 @@ "metrics": { "timing": { "fit_time_ms": 17.37356185913086, - "std_ms": 0.1751727379638956, + "std_ms": 0.175172737964, "min_ms": 17.317146062850952, "max_ms": 17.713725566864014, "sample_count": 3, @@ -88450,7 +88450,7 @@ "metrics": { "timing": { "fit_time_ms": 12.376457452774048, - "std_ms": 0.14695390356878774, + "std_ms": 0.146953903569, "min_ms": 12.127071619033813, "max_ms": 12.476563453674316, "sample_count": 3, @@ -88605,7 +88605,7 @@ "metrics": { "timing": { "fit_time_ms": 7.113069295883179, - "std_ms": 0.022110917652291093, + "std_ms": 0.022110917652, "min_ms": 7.089287042617798, "max_ms": 7.1433186531066895, "sample_count": 3, @@ -88760,7 +88760,7 @@ "metrics": { "timing": { "fit_time_ms": 29.22457456588745, - "std_ms": 0.07344943972222218, + "std_ms": 0.073449439722, "min_ms": 29.094338417053223, "max_ms": 29.266953468322754, "sample_count": 3, @@ -88915,7 +88915,7 @@ "metrics": { "timing": { "fit_time_ms": 76.48885250091553, - "std_ms": 0.7515277112219283, + "std_ms": 0.751527711222, "min_ms": 76.3988196849823, "max_ms": 78.03615927696228, "sample_count": 3, @@ -89070,7 +89070,7 @@ "metrics": { "timing": { "fit_time_ms": 34.95398163795471, - "std_ms": 0.08122915143822747, + "std_ms": 0.081229151438, "min_ms": 34.94828939437866, "max_ms": 35.12337803840637, "sample_count": 3, @@ -89225,7 +89225,7 @@ "metrics": { "timing": { "fit_time_ms": 7.375836372375488, - "std_ms": 0.2661149489547812, + "std_ms": 0.266114948955, "min_ms": 7.340103387832642, "max_ms": 7.92163610458374, "sample_count": 3, @@ -89381,7 +89381,7 @@ "metrics": { "timing": { "fit_time_ms": 75.77601075172424, - "std_ms": 0.4520580207552138, + "std_ms": 0.452058020755, "min_ms": 75.26275515556335, "max_ms": 76.36910676956177, "sample_count": 3, @@ -89538,7 +89538,7 @@ "metrics": { "timing": { "fit_time_ms": 153.40235829353333, - "std_ms": 0.5537958099223217, + "std_ms": 0.553795809922, "min_ms": 153.37586402893066, "max_ms": 154.56366539001465, "sample_count": 3, @@ -89695,7 +89695,7 @@ "metrics": { "timing": { "fit_time_ms": 121.93247675895691, - "std_ms": 0.2863016881758537, + "std_ms": 0.286301688176, "min_ms": 121.55237793922424, "max_ms": 122.25282192230225, "sample_count": 3, @@ -89852,7 +89852,7 @@ "metrics": { "timing": { "fit_time_ms": 7.36507773399353, - "std_ms": 0.0928811561208376, + "std_ms": 0.092881156121, "min_ms": 7.2509050369262695, "max_ms": 7.4784159660339355, "sample_count": 3, @@ -90008,7 +90008,7 @@ "metrics": { "timing": { "fit_time_ms": 51.06106400489807, - "std_ms": 0.12425235011605137, + "std_ms": 0.124252350116, "min_ms": 50.835102796554565, "max_ms": 51.12466216087341, "sample_count": 3, @@ -90163,7 +90163,7 @@ "metrics": { "timing": { "fit_time_ms": 95.80263495445251, - "std_ms": 3.1773095837367222, + "std_ms": 3.177309583737, "min_ms": 89.1546905040741, "max_ms": 95.98329663276672, "sample_count": 3, @@ -90318,7 +90318,7 @@ "metrics": { "timing": { "fit_time_ms": 49.2972731590271, - "std_ms": 2.079922258152906, + "std_ms": 2.079922258153, "min_ms": 48.696696758270264, "max_ms": 53.378403186798096, "sample_count": 3, @@ -90473,7 +90473,7 @@ "metrics": { "timing": { "fit_time_ms": 32.66507387161255, - "std_ms": 0.16058180541689593, + "std_ms": 0.160581805417, "min_ms": 32.47341513633728, "max_ms": 32.866716384887695, "sample_count": 3, @@ -90628,7 +90628,7 @@ "metrics": { "timing": { "fit_time_ms": 5.652785301208496, - "std_ms": 0.0647337375076041, + "std_ms": 0.064733737508, "min_ms": 5.633354187011719, "max_ms": 5.779355764389038, "sample_count": 3, @@ -90783,7 +90783,7 @@ "metrics": { "timing": { "fit_time_ms": 79.96299862861633, - "std_ms": 0.3447674872577324, + "std_ms": 0.344767487258, "min_ms": 79.8010528087616, "max_ms": 80.5998146533966, "sample_count": 3, @@ -90938,7 +90938,7 @@ "metrics": { "timing": { "fit_time_ms": 53.66373062133789, - "std_ms": 0.07744715297714648, + "std_ms": 0.077447152977, "min_ms": 53.63589525222778, "max_ms": 53.81232500076294, "sample_count": 3, @@ -91093,7 +91093,7 @@ "metrics": { "timing": { "fit_time_ms": 368.74711513519287, - "std_ms": 1.0174916822778004, + "std_ms": 1.017491682278, "min_ms": 367.16771125793457, "max_ms": 369.62711811065674, "sample_count": 3, @@ -91248,7 +91248,7 @@ "metrics": { "timing": { "fit_time_ms": 393.74133944511414, - "std_ms": 10.05315461953889, + "std_ms": 10.053154619539, "min_ms": 372.9921281337738, "max_ms": 394.8514759540558, "sample_count": 3, @@ -91403,7 +91403,7 @@ "metrics": { "timing": { "fit_time_ms": 229.87377643585205, - "std_ms": 0.8445346932663552, + "std_ms": 0.844534693266, "min_ms": 229.26145792007446, "max_ms": 231.27886652946472, "sample_count": 3, diff --git a/frontend/public/data/parse_report.json b/frontend/public/data/parse_report.json index 4705a2b3f..af05c2ebc 100644 --- a/frontend/public/data/parse_report.json +++ b/frontend/public/data/parse_report.json @@ -4,7 +4,7 @@ "files_parsed": 11, "files_skipped": 0, "runs_generated": 1852, - "generation_id": "9543fdc0b57ceabcb1323c257b4a313e48866439059782263f8a6970b1a0b65d", + "generation_id": "820a294b2b6fd58f6c1384b5ffad602f20168dc30102f93a49895e97fb0003dc", "issues": [ { "source_id": "glm-solver-20260623-1b6197d94d88", diff --git a/frontend/public/data/source_inventory.json b/frontend/public/data/source_inventory.json index 24bfb8227..322080ace 100644 --- a/frontend/public/data/source_inventory.json +++ b/frontend/public/data/source_inventory.json @@ -1645,5 +1645,5 @@ "current_evidence_not_canonical_ready": 2, "partial_canonical": 7 }, - "generation_id": "9543fdc0b57ceabcb1323c257b4a313e48866439059782263f8a6970b1a0b65d" + "generation_id": "820a294b2b6fd58f6c1384b5ffad602f20168dc30102f93a49895e97fb0003dc" } \ No newline at end of file From aa74e4386621439752c69021184d065db39dfc3b Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 16:38:14 +0800 Subject: [PATCH 054/165] fix: address panel diagnostics review findings --- statgpu/panel/_diagnostic_context.py | 109 +++++++++++++++++++++++++-- 1 file changed, 101 insertions(+), 8 deletions(-) diff --git a/statgpu/panel/_diagnostic_context.py b/statgpu/panel/_diagnostic_context.py index e0959eb66..6babaa9ad 100644 --- a/statgpu/panel/_diagnostic_context.py +++ b/statgpu/panel/_diagnostic_context.py @@ -22,6 +22,66 @@ from statgpu.panel._utils import group_means, group_sizes +def _two_way_incidence_components( + entity_codes, + time_codes, + *, + n_entities: int, + n_times: int, +) -> int: + """Count connected components in the observed entity-time incidence graph.""" + if entity_codes is None or time_codes is None: + raise ValueError( + "two-way fixed-effect diagnostic rank requires entity and time codes" + ) + + entity = np.asarray(_to_numpy(entity_codes), dtype=np.int64).ravel() + time = np.asarray(_to_numpy(time_codes), dtype=np.int64).ravel() + if entity.shape != time.shape: + raise ValueError("entity and time codes must have the same length") + + n_entities = int(n_entities) + n_times = int(n_times) + total = n_entities + n_times + parent = np.arange(total, dtype=np.int64) + rank = np.zeros(total, dtype=np.int8) + + def find(node: int) -> int: + root = int(node) + while parent[root] != root: + root = int(parent[root]) + while parent[node] != node: + nxt = int(parent[node]) + parent[node] = root + node = nxt + return root + + def union(left: int, right: int) -> None: + left_root = find(left) + right_root = find(right) + if left_root == right_root: + return + if rank[left_root] < rank[right_root]: + left_root, right_root = right_root, left_root + parent[right_root] = left_root + if rank[left_root] == rank[right_root]: + rank[left_root] += 1 + + for entity_code, time_code in zip(entity, time): + entity_code = int(entity_code) + time_code = int(time_code) + if not (0 <= entity_code < n_entities): + raise ValueError("entity diagnostic code is out of range") + if not (0 <= time_code < n_times): + raise ValueError("time diagnostic code is out of range") + union(entity_code, n_entities + time_code) + + active = np.zeros(total, dtype=bool) + active[entity] = True + active[n_entities + time] = True + return len({find(int(node)) for node in np.flatnonzero(active)}) + + def effect_rank_standard( *, n_entities: int, @@ -29,23 +89,28 @@ def effect_rank_standard( entity_effects: bool, time_effects: bool, has_constant: bool = False, + n_components: int = 1, ) -> int: """Return the nuisance-effect rank under the standard FE parameterization.""" n_entities = int(n_entities) n_times = int(n_times) + n_components = int(n_components) if not entity_effects and not time_effects: return 0 + if entity_effects and time_effects: + if n_components <= 0: + raise ValueError("two-way incidence component count must be positive") + full_dummy_rank = max(n_entities + n_times - n_components, 0) + if has_constant: + return int(max(full_dummy_rank - 1, 0)) + return int(full_dummy_rank) + if has_constant: - rank = 0 if entity_effects: - rank += max(n_entities - 1, 0) - if time_effects: - rank += max(n_times - 1, 0) - return int(rank) + return int(max(n_entities - 1, 0)) + return int(max(n_times - 1, 0)) - if entity_effects and time_effects: - return int(max(n_entities + n_times - 1, 0)) if entity_effects: return int(max(n_entities, 0)) return int(max(n_times, 0)) @@ -61,15 +126,26 @@ def fixed_effect_diagnostic_df( entity_effects: bool, time_effects: bool, has_constant: bool = False, + entity_codes=None, + time_codes=None, ): """Return rank-consistent Stage-B FE diagnostic df without changing legacy df.""" rank_x = _matrix_rank(X_transformed, xp) + n_components = 1 + if entity_effects and time_effects: + n_components = _two_way_incidence_components( + entity_codes, + time_codes, + n_entities=n_entities, + n_times=n_times, + ) effect_rank = effect_rank_standard( n_entities=n_entities, n_times=n_times, entity_effects=entity_effects, time_effects=time_effects, has_constant=has_constant, + n_components=n_components, ) df_resid = int(nobs) - int(rank_x) - int(effect_rank) df_total = int(nobs) - int(effect_rank) @@ -78,10 +154,27 @@ def fixed_effect_diagnostic_df( "effect_rank": int(effect_rank), "df_resid": int(df_resid), "df_total": int(df_total), + "incidence_components": int(n_components), "legacy_df_unchanged": True, } +def explicit_constant_column(X, *, xp): + """Return an identified explicit constant-column index, if one is present.""" + if int(X.shape[1]) == 0: + return None + col_min = np.asarray(_to_numpy(xp.min(X, axis=0)), dtype=np.float64).ravel() + col_max = np.asarray(_to_numpy(xp.max(X, axis=0)), dtype=np.float64).ravel() + scale = np.maximum(1.0, np.maximum(np.abs(col_min), np.abs(col_max))) + tol = 256.0 * np.finfo(np.float64).eps * scale + span = np.abs(col_max - col_min) + magnitude = np.maximum(np.abs(col_min), np.abs(col_max)) + candidates = np.flatnonzero((span <= tol) & (magnitude > tol)) + if candidates.size == 0: + return None + return int(candidates[0]) + + def pooling_f_from_level_arrays( y, X, @@ -220,4 +313,4 @@ def build_model_fit_statistics(*args, **kwargs): def build_diagnostic_identity(*args, **kwargs): """Thin estimator-facing wrapper around the shared numerical fingerprint.""" - return _diagnostic_identity(*args, **kwargs) \ No newline at end of file + return _diagnostic_identity(*args, **kwargs) From 7dcc7bf7f9adb69d976bda5cfb4d6a34d9172210 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 16:39:00 +0800 Subject: [PATCH 055/165] fix: use observed two-way incidence rank --- statgpu/panel/_fixed_effects.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/statgpu/panel/_fixed_effects.py b/statgpu/panel/_fixed_effects.py index 472256bf9..eedf2d5d9 100644 --- a/statgpu/panel/_fixed_effects.py +++ b/statgpu/panel/_fixed_effects.py @@ -285,6 +285,8 @@ def fit( entity_effects=self.entity_effects, time_effects=self.time_effects, has_constant=False, + entity_codes=entity_arr, + time_codes=time_arr, ) ss_tot_diag = _to_float_scalar(xp.sum(y_d * y_d)) self.fit_statistics_ = build_model_fit_statistics( From f8b107133728be215b113fae91ee0b0df5c8216d Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 16:41:34 +0800 Subject: [PATCH 056/165] fix: harden Hausman identity and exact-fit model F --- statgpu/panel/_diagnostics.py | 93 ++++++++++++++++++++++++++--------- 1 file changed, 71 insertions(+), 22 deletions(-) diff --git a/statgpu/panel/_diagnostics.py b/statgpu/panel/_diagnostics.py index 54ca03e90..e579bb26a 100644 --- a/statgpu/panel/_diagnostics.py +++ b/statgpu/panel/_diagnostics.py @@ -2,9 +2,10 @@ Stage B of Issue #93 adds structured specification tests and parameter-based fit statistics without changing the Stage-A estimator transformations or -covariance definitions. Observation-scale accumulation stays on the selected -NumPy/CuPy/Torch backend; public diagnostic results contain only CPU scalars -and small metadata. +covariance definitions. Observation-scale statistical accumulation stays on the +selected NumPy/CuPy/Torch backend. Hausman sample identity additionally uses a +chunked full-content SHA-256 over normalized float64 X/y values so different +aligned samples cannot be accepted merely because low-order moments collide. """ from __future__ import annotations @@ -178,10 +179,13 @@ def _classical_model_f( xp, df_resid: int, has_constant: bool, + restricted_X=None, ) -> Tuple[Optional[float], Optional[float], Optional[Tuple[float, float]], Dict[str, Any]]: """Classical homoskedastic joint-slope F statistic in the fit space.""" rank_u = _matrix_rank(X, xp) - rank_r = 1 if has_constant else 0 + rank_r = _matrix_rank(restricted_X, xp) if restricted_X is not None else ( + 1 if has_constant else 0 + ) q = rank_u - rank_r metadata = { "classical_homoskedastic": True, @@ -189,13 +193,19 @@ def _classical_model_f( "rank_restricted": rank_r, "restriction_rank": q, } + if restricted_X is not None: + metadata["restricted_design_supplied"] = True if q <= 0 or int(df_resid) <= 0: metadata["unavailable_reason"] = "no estimable non-constant restrictions" return None, None, None, metadata resid = y - X @ params.ravel() rss_u = _to_float_scalar(xp.sum(resid * resid)) - if has_constant: + if restricted_X is not None: + beta_r = xp.linalg.pinv(restricted_X) @ y + resid_r = y - restricted_X @ beta_r + rss_r = _to_float_scalar(xp.sum(resid_r * resid_r)) + elif has_constant: y_r = y - xp.mean(y) rss_r = _to_float_scalar(xp.sum(y_r * y_r)) else: @@ -212,15 +222,25 @@ def _classical_model_f( diff = 0.0 metadata["roundoff_normalized"] = True - if rss_u <= 0.0: - metadata["unavailable_reason"] = "unrestricted residual sum of squares is zero" + metadata["rss_restricted"] = float(rss_r) + metadata["rss_unrestricted"] = float(rss_u) + if rss_u <= tol: + if diff > tol: + metadata["exact_fit"] = True + return ( + float("inf"), + 0.0, + (float(q), float(df_resid)), + metadata, + ) + metadata["unavailable_reason"] = ( + "restricted and unrestricted residual sums of squares are both zero" + ) return None, None, None, metadata statistic = (diff / q) / (rss_u / int(df_resid)) dist = get_distribution("f", backend="numpy") pvalue = _to_float_scalar(dist.sf(statistic, q, int(df_resid))) - metadata["rss_restricted"] = float(rss_r) - metadata["rss_unrestricted"] = float(rss_u) return float(statistic), float(pvalue), (float(q), float(df_resid)), metadata @@ -240,6 +260,7 @@ def _build_fit_statistics( f_X=None, f_params=None, f_has_constant: Optional[bool] = None, + f_restricted_X=None, metadata: Optional[Dict[str, Any]] = None, ) -> PanelFitStatistics: within, between, overall, degenerate = _parameter_r2_components( @@ -259,6 +280,7 @@ def _build_fit_statistics( has_constant=( bool(has_constant) if f_has_constant is None else bool(f_has_constant) ), + restricted_X=f_restricted_X, ) meta = {} if metadata is None else dict(metadata) meta.setdefault("r2_definition", "parameter-based") @@ -533,8 +555,38 @@ def _row_weights(n: int, xp, ref_arr): return xp.arange(1, int(n) + 1, dtype=xp.float64) -def _numerical_fingerprint(X, y, *, xp) -> Dict[str, np.ndarray]: - """Reduce aligned X/y/order to O(k) deterministic float64 moments.""" +def _full_content_digest(X, y) -> str: + """Hash every aligned X/y value with bounded chunked host transfers.""" + h = hashlib.sha256() + h.update(b"statgpu-panel-diagnostic-identity-v2") + + for label, array, shape in ( + (b"X", X, (int(X.shape[0]), int(X.shape[1]))), + (b"y", y, (int(y.shape[0]),)), + ): + h.update(label) + h.update(np.asarray(shape, dtype=" Dict[str, Any]: + """Retain audit moments plus an authoritative full-content digest.""" n = int(X.shape[0]) weights = _row_weights(n, xp, X) X_sum = xp.sum(X, axis=0) @@ -544,6 +596,7 @@ def _numerical_fingerprint(X, y, *, xp) -> Dict[str, np.ndarray]: y_sq = xp.sum(y * y) y_weighted = xp.sum(y * weights) return { + "content_digest": _full_content_digest(X, y), "X_sum": np.asarray(_to_numpy(X_sum), dtype=np.float64).ravel(), "X_sq": np.asarray(_to_numpy(X_sq), dtype=np.float64).ravel(), "X_weighted": np.asarray(_to_numpy(X_weighted), dtype=np.float64).ravel(), @@ -597,16 +650,12 @@ def _fingerprints_match(left: Dict[str, Any], right: Dict[str, Any]) -> Tuple[bo rf = right.get("fingerprint") if not isinstance(lf, dict) or not isinstance(rf, dict): return False, "diagnostic identity is missing numerical fingerprint metadata" - for key in ("X_sum", "X_sq", "X_weighted", "y"): - if key not in lf or key not in rf: - return False, f"diagnostic fingerprint is missing {key}" - if not np.allclose( - np.asarray(lf[key]), - np.asarray(rf[key]), - rtol=5e-11, - atol=5e-12, - ): - return False, f"diagnostic numerical fingerprint mismatch: {key}" + left_digest = lf.get("content_digest") + right_digest = rf.get("content_digest") + if not isinstance(left_digest, str) or not isinstance(right_digest, str): + return False, "diagnostic fingerprint is missing full-content digest" + if left_digest != right_digest: + return False, "diagnostic numerical fingerprint mismatch: content_digest" return True, "" @@ -742,4 +791,4 @@ def hausman_test(fe_model, re_model) -> PanelTestResult: applicable=result.applicable, reason=result.reason, metadata=meta, - ) + ) \ No newline at end of file From aeded4f71a59636e1f9f3b63a85b0ce0cd72a23b Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 16:43:29 +0800 Subject: [PATCH 057/165] fix: detect explicit constants in RandomEffects diagnostics --- statgpu/panel/_random_effects.py | 43 +++++++++++++++++++++++++++----- 1 file changed, 37 insertions(+), 6 deletions(-) diff --git a/statgpu/panel/_random_effects.py b/statgpu/panel/_random_effects.py index 47e487799..cd667d896 100644 --- a/statgpu/panel/_random_effects.py +++ b/statgpu/panel/_random_effects.py @@ -110,7 +110,16 @@ def fit( # new array-interface validation rule for it in this refactor. self._panel_set_index_info(n, entity_ids=entity_ids) - from statgpu.panel._diagnostic_context import build_diagnostic_identity + from statgpu.panel._diagnostic_context import ( + build_diagnostic_identity, + explicit_constant_column, + ) + + # Detect an explicit nonzero constant in the supplied level design. + # RandomEffects does not implicitly add an intercept, so this flag must + # describe the caller's actual X rather than the model family. + constant_index = explicit_constant_column(X_arr, xp=xp) + has_constant = constant_index is not None # Hausman compatibility is checked against aligned level X/y/entity # metadata, before any Swamy-Arora transformation is applied. @@ -120,7 +129,7 @@ def fit( xp=xp, entity_codes=entity_arr, feature_names=self._feature_names, - has_constant=False, + has_constant=has_constant, ) # --- Step 1: Between estimation --- @@ -259,27 +268,49 @@ def fit( rank_star = _matrix_rank(X_star, xp) diagnostic_df_resid = n - rank_star ss_res_diag = _to_float_scalar(xp.sum(resid_gls * resid_gls)) - ss_tot_diag = _to_float_scalar(xp.sum(y_star * y_star)) + + # In the quasi-demeaned fit space, an explicit level intercept becomes + # the transformed intercept column X_star[:, constant_index]. On an + # unbalanced panel this is not generally a vector of ones, so both the + # adjusted-R² denominator and the restricted model F must retain that + # exact transformed column. + restricted_X = None + restricted_rank = 0 + if has_constant: + restricted_X = X_star[:, constant_index : constant_index + 1] + restricted_rank = _matrix_rank(restricted_X, xp) + restricted_params = xp.linalg.pinv(restricted_X) @ y_star + restricted_resid = y_star - restricted_X @ restricted_params + ss_tot_diag = _to_float_scalar( + xp.sum(restricted_resid * restricted_resid) + ) + else: + ss_tot_diag = _to_float_scalar(xp.sum(y_star * y_star)) + self.fit_statistics_ = build_model_fit_statistics( y_arr, X_arr, beta_gls, xp=xp, entity_codes=entity_arr, - has_constant=False, + has_constant=has_constant, rss_fit=ss_res_diag, tss_fit=ss_tot_diag, df_resid=diagnostic_df_resid, - df_total=n, + df_total=n - restricted_rank, f_y=y_star, f_X=X_star, f_params=beta_gls, - f_has_constant=False, + f_has_constant=has_constant, + f_restricted_X=restricted_X, metadata={ "fit_space": "Swamy-Arora quasi-demeaned GLS regression", "legacy_df_resid": int(self.df_resid), "diagnostic_df_resid": int(diagnostic_df_resid), "diagnostic_rank": int(rank_star), + "has_explicit_constant": bool(has_constant), + "constant_column_index": constant_index, + "restricted_rank": int(restricted_rank), }, ) From a5961376444d1836fcb22950a1ead2c7c79f07d0 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 16:44:52 +0800 Subject: [PATCH 058/165] fix: preserve Torch constant-column detection --- statgpu/panel/_diagnostic_context.py | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/statgpu/panel/_diagnostic_context.py b/statgpu/panel/_diagnostic_context.py index 6babaa9ad..e069055ea 100644 --- a/statgpu/panel/_diagnostic_context.py +++ b/statgpu/panel/_diagnostic_context.py @@ -163,8 +163,14 @@ def explicit_constant_column(X, *, xp): """Return an identified explicit constant-column index, if one is present.""" if int(X.shape[1]) == 0: return None - col_min = np.asarray(_to_numpy(xp.min(X, axis=0)), dtype=np.float64).ravel() - col_max = np.asarray(_to_numpy(xp.max(X, axis=0)), dtype=np.float64).ravel() + if getattr(xp, "__name__", "") == "torch": + min_native = xp.amin(X, dim=0) + max_native = xp.amax(X, dim=0) + else: + min_native = xp.min(X, axis=0) + max_native = xp.max(X, axis=0) + col_min = np.asarray(_to_numpy(min_native), dtype=np.float64).ravel() + col_max = np.asarray(_to_numpy(max_native), dtype=np.float64).ravel() scale = np.maximum(1.0, np.maximum(np.abs(col_min), np.abs(col_max))) tol = 256.0 * np.finfo(np.float64).eps * scale span = np.abs(col_max - col_min) From 2eac10df1f763050c6e719cd47c616362d4769e6 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 16:45:25 +0800 Subject: [PATCH 059/165] test: cover panel Stage B review regressions --- .../test_panel_stage_b_review_regressions.py | 139 ++++++++++++++++++ 1 file changed, 139 insertions(+) create mode 100644 dev/tests/test_panel_stage_b_review_regressions.py diff --git a/dev/tests/test_panel_stage_b_review_regressions.py b/dev/tests/test_panel_stage_b_review_regressions.py new file mode 100644 index 000000000..138a75409 --- /dev/null +++ b/dev/tests/test_panel_stage_b_review_regressions.py @@ -0,0 +1,139 @@ +"""Regression tests for PR #122 review findings closed after physical promotion.""" + +from __future__ import annotations + +import numpy as np +from numpy.testing import assert_allclose + +from statgpu.panel import RandomEffects +from statgpu.panel._diagnostic_context import fixed_effect_diagnostic_df +from statgpu.panel._diagnostics import ( + _classical_model_f, + _diagnostic_identity, + _fingerprints_match, +) + + +def test_two_way_effect_rank_counts_disconnected_incidence_components(): + # Two disconnected incidence components: + # {entities 0,1} x {times 0,1} and {entities 2,3} x {times 2,3}. + entity = np.asarray([0, 0, 1, 1, 2, 2, 3, 3], dtype=np.int64) + time = np.asarray([0, 1, 0, 1, 2, 3, 2, 3], dtype=np.int64) + X_transformed = np.arange(1.0, 9.0).reshape(-1, 1) + + result = fixed_effect_diagnostic_df( + X_transformed, + xp=np, + nobs=8, + n_entities=4, + n_times=4, + entity_effects=True, + time_effects=True, + entity_codes=entity, + time_codes=time, + ) + + assert result["incidence_components"] == 2 + assert result["effect_rank"] == 4 + 4 - 2 + assert result["rank_x"] == 1 + assert result["df_resid"] == 1 + assert result["df_total"] == 2 + + +def test_hausman_identity_rejects_low_order_moment_collision(): + # These response vectors have the same sum, sum of squares, and + # row-weighted sum. The previous low-order fingerprint therefore collided. + y_left = np.asarray([0.0, 1.0, 3.0, 2.0]) + y_right = np.asarray([0.0, 2.0, 1.0, 3.0]) + X = np.asarray( + [ + [0.2, -0.4], + [0.7, 0.1], + [-0.3, 0.5], + [1.1, -0.2], + ] + ) + entity = np.asarray([0, 0, 1, 1], dtype=np.int64) + + assert y_left.sum() == y_right.sum() + assert np.dot(y_left, y_left) == np.dot(y_right, y_right) + weights = np.arange(1.0, 5.0) + assert np.dot(y_left, weights) == np.dot(y_right, weights) + + left = _diagnostic_identity(X, y_left, xp=np, entity_codes=entity) + right = _diagnostic_identity(X, y_right, xp=np, entity_codes=entity) + matched, reason = _fingerprints_match(left, right) + + assert not matched + assert "content_digest" in reason + assert ( + left["fingerprint"]["content_digest"] + != right["fingerprint"]["content_digest"] + ) + + +def test_classical_model_f_reports_infinite_statistic_for_exact_fit(): + x = np.linspace(-1.0, 1.0, 8) + X = np.column_stack([np.ones(x.size), x]) + params = np.asarray([1.25, -0.8]) + y = X @ params + + statistic, pvalue, df, metadata = _classical_model_f( + y, + X, + params, + xp=np, + df_resid=x.size - np.linalg.matrix_rank(X), + has_constant=True, + ) + + assert np.isinf(statistic) + assert pvalue == 0.0 + assert df == (1.0, 6.0) + assert metadata["exact_fit"] is True + assert metadata["rss_restricted"] > 0.0 + assert metadata["rss_unrestricted"] <= metadata["rss_restricted"] + + +def test_random_effects_explicit_constant_uses_constant_aware_diagnostics(): + rng = np.random.default_rng(20260808) + counts = np.asarray([5, 4, 3, 5, 4, 3]) + entity = np.repeat(np.arange(counts.size), counts) + slope = rng.normal(size=entity.size) + X = np.column_stack([np.ones(entity.size), slope]) + alpha = np.repeat(np.linspace(-0.4, 0.5, counts.size), counts) + y = 1.7 + 0.65 * slope + alpha + rng.normal(scale=0.12, size=entity.size) + + model = RandomEffects().fit(X, y, entity_ids=entity) + result = model.fit_statistics_ + + assert result.metadata["has_explicit_constant"] is True + assert result.metadata["constant_column_index"] == 0 + assert result.metadata["restricted_rank"] == 1 + assert result.metadata["model_f"]["rank_restricted"] == 1 + assert result.metadata["model_f"]["restricted_design_supplied"] is True + assert result.f_df == (1.0, float(entity.size - np.linalg.matrix_rank(X))) + + level_resid = y - X @ model.coef_ + expected_overall = 1.0 - np.dot(level_resid, level_resid) / np.sum( + (y - y.mean()) ** 2 + ) + assert_allclose(result.rsquared_overall, expected_overall, rtol=1e-12, atol=1e-12) + + +def test_random_effects_without_constant_preserves_uncentered_diagnostic_basis(): + rng = np.random.default_rng(20260809) + entity = np.repeat(np.arange(6), 4) + X = rng.normal(size=(entity.size, 2)) + y = X @ np.asarray([0.7, -0.3]) + np.repeat( + np.linspace(-0.3, 0.4, 6), 4 + ) + rng.normal(scale=0.15, size=entity.size) + + model = RandomEffects().fit(X, y, entity_ids=entity) + result = model.fit_statistics_ + + assert result.metadata["has_explicit_constant"] is False + assert result.metadata["constant_column_index"] is None + assert result.metadata["restricted_rank"] == 0 + assert result.metadata["model_f"].get("restricted_design_supplied") is None + assert result.metadata["model_f"]["rank_restricted"] == 0 From 671be50b413d6cbed653e13df3ce414ef4b8035f Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 16:45:58 +0800 Subject: [PATCH 060/165] test: cover Torch explicit-constant diagnostics --- dev/tests/test_panel_stage_b_torch_cpu.py | 26 +++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/dev/tests/test_panel_stage_b_torch_cpu.py b/dev/tests/test_panel_stage_b_torch_cpu.py index ffbab3ade..9e32d2368 100644 --- a/dev/tests/test_panel_stage_b_torch_cpu.py +++ b/dev/tests/test_panel_stage_b_torch_cpu.py @@ -143,6 +143,32 @@ def test_stage_b_random_effects_torch_cpu_fit_stats_and_identity_match_numpy(): assert h_actual.reason == h_expected.reason +def test_stage_b_random_effects_explicit_constant_torch_cpu_matches_numpy(): + rng = np.random.default_rng(1224) + counts = np.asarray([5, 4, 3, 5, 4, 3]) + entity = np.repeat(np.arange(counts.size), counts) + time = np.concatenate([np.arange(count) for count in counts]) + slope = rng.normal(size=entity.size) + X = np.column_stack([np.ones(entity.size), slope]) + alpha = np.repeat(np.linspace(-0.45, 0.55, counts.size), counts) + y = 1.4 + 0.72 * slope + alpha + rng.normal(scale=0.14, size=entity.size) + X_t, y_t, entity_t, _ = _torch_arrays(X, y, entity, time) + + expected = RandomEffects().fit(X, y, entity_ids=entity) + actual = RandomEffects().fit(X_t, y_t, entity_ids=entity_t) + + assert_allclose(actual.coef_, expected.coef_, rtol=1e-9, atol=1e-10) + _assert_fit_statistics_close(actual.fit_statistics_, expected.fit_statistics_) + assert actual.fit_statistics_.metadata["has_explicit_constant"] is True + assert actual.fit_statistics_.metadata["constant_column_index"] == 0 + assert actual.fit_statistics_.metadata["model_f"]["rank_restricted"] == 1 + assert actual.fit_statistics_.metadata["model_f"]["restricted_design_supplied"] is True + assert ( + actual._panel_diagnostic_identity["fingerprint"]["content_digest"] + == expected._panel_diagnostic_identity["fingerprint"]["content_digest"] + ) + + def test_stage_b_fama_macbeth_torch_cpu_r2_matches_numpy_without_ols_f(): X, y, entity, time = _panel(seed=1223) X_t, y_t, entity_t, time_t = _torch_arrays(X, y, entity, time) From 6ca83ee23e1c176c1f1c9e4c80223d67ed5bee78 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 16:51:16 +0800 Subject: [PATCH 061/165] docs: align panel diagnostics contracts with review fixes --- docs/en/models/panel.md | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) diff --git a/docs/en/models/panel.md b/docs/en/models/panel.md index f7767ece5..2a399f31d 100644 --- a/docs/en/models/panel.md +++ b/docs/en/models/panel.md @@ -128,7 +128,7 @@ For coefficient vector \(\hat\beta\): - **between R²** evaluates entity means \(\bar y_i-\bar X_i\hat\beta\); - **within R²** evaluates entity-demeaned \(y\) and \(X\). -Overall and between total sums of squares are centered only when the actual level regressor design contains an identified constant. Fixed effects by themselves do not change this centering rule. A zero total sum of squares is reported as `0.0` in the standardized Stage-B field and marked in `metadata["degenerate_total_ss"]`. +Overall and between total sums of squares are centered only when the actual level regressor design contains an identified constant. Fixed effects by themselves do not change this centering rule. `RandomEffects` detects an explicit nonzero constant column in the supplied level design and retains its quasi-demeaned transformed column when defining adjusted R² and the restricted model-F regression. A zero total sum of squares is reported as `0.0` in the standardized Stage-B field and marked in `metadata["degenerate_total_ss"]`. ### Legacy `PanelOLS.rsquared_within` @@ -140,7 +140,9 @@ For new standardized diagnostics, `PanelOLS` uses the rank of the complete fixed - entity effects only: \(N\); - time effects only: \(T\); -- entity and time effects: \(N+T-1\). +- entity and time effects: \(N+T-C\), where \(C\) is the number of connected components in the observed entity-time incidence graph. + +Thus the familiar \(N+T-1\) formula is the connected-panel special case \(C=1\); incomplete panels with disconnected incidence components receive their actual dummy-space rank rather than a hard-coded connected-panel rank. If \(r_X\) is the numerical rank of the transformed slope design, Stage B uses @@ -170,7 +172,7 @@ F= {RSS_U/\mathrm{df}_{\mathrm{resid}}}, $$ -where \(q\) is the effective restriction rank. A robust or clustered covariance choice does not silently convert this field into a robust Wald test. +where \(q\) is the effective restriction rank. A robust or clustered covariance choice does not silently convert this field into a robust Wald test. When the unrestricted regression fits exactly while the restricted regression has positive RSS, the standardized result is the limiting classical value `F=inf`, `p=0` rather than an unavailable statistic. `FamaMacBeth` does not receive a residual-OLS model F or adjusted R². Its covariance is based on the time series of cross-sectional coefficient estimates, and Stage B does not relabel that beta-series inference as residual OLS. @@ -235,10 +237,12 @@ Applicability rules are explicit: - FE must be one-way entity effects only; - the FE coefficient covariance must be classical/nonrobust; - FE and RE must be fitted to the same aligned X/y/entity sample and common slope design; -- row/sample compatibility is checked using compact backend-native numerical fingerprints, not just matching shapes; +- row/sample compatibility uses a collision-resistant SHA-256 digest of every aligned float64 X/y value plus the entity-code signature and feature metadata, not only matching shapes or low-order moments; - intercepts are excluded from the comparison; - a materially indefinite covariance difference is reported as inapplicable instead of being eigenvalue-clipped into a statistic. +For GPU fits, the full-content digest is computed through bounded chunks copied to host solely for hashing. The fitted model stores only the digest and compact metadata; it does not retain a second CPU copy of the full design. Statistical estimation, covariance construction, and fit-statistic reductions remain on the selected numerical backend. + If the covariance difference is positive semidefinite but rank-deficient, statgpu provides a documented generalized-inverse extension: the test uses the identified range and chi-square degrees of freedom equal to the numerical rank, but only when the coefficient difference lies in that range. Metadata records `used_pinv=True` and labels this as the `singular PSD generalized-inverse Hausman` extension. Robust auxiliary-regression Hausman is not part of Stage B. ## Parameters and Fit Signatures @@ -327,7 +331,7 @@ re = RandomEffects(device="cpu").fit(X, y, entity_ids=entity_ids) print(fe.hausman_test(re)) ``` -For CuPy CUDA use `device="cuda"`; for Torch CUDA use CUDA tensors and `device="torch"`. Stage-B sufficient-statistic accumulation follows the selected numerical backend. Only compact metadata, final scalars, and small covariance matrices cross the CPU metadata boundary. +For CuPy CUDA use `device="cuda"`; for Torch CUDA use CUDA tensors and `device="torch"`. Stage-B statistical transforms and sufficient-statistic accumulation follow the selected numerical backend. Formula/label metadata, final scalars, and small covariance matrices use the CPU metadata boundary; Hausman additionally performs a bounded chunked host copy of aligned X/y solely to compute the full-content identity digest. ## Outputs @@ -344,7 +348,7 @@ Common fitted attributes include: ## Formula and Metadata Boundaries -Formula evaluation may drop rows with missing values. Entity, time, cluster, and other side arrays are aligned to the retained rows. String and categorical labels are factorized on CPU; numerical transforms and sufficient-statistic calculations remain on the selected backend. Hausman stores only compact sample/design fingerprints and a small covariance matrix rather than a second CPU copy of the full design. +Formula evaluation may drop rows with missing values. Entity, time, cluster, and other side arrays are aligned to the retained rows. String and categorical labels are factorized on CPU; numerical transforms and sufficient-statistic calculations remain on the selected backend. Hausman computes a full-content SHA-256 identity by copying aligned X/y to host in bounded chunks, then stores only the digest, feature/entity metadata, and a small covariance matrix rather than a second CPU copy of the full design. ## Validation @@ -360,4 +364,4 @@ Stage B adds maintained analytic and fitted-model regression tests, formula/miss - White, H. (1980). A heteroskedasticity-consistent covariance matrix estimator. - Newey, W. K., & West, K. D. (1987). A simple, positive semi-definite, heteroskedasticity and autocorrelation consistent covariance matrix. - Fama, E. F., & MacBeth, J. D. (1973). Risk, return, and equilibrium. -- Cameron, A. C., Gelbach, J. B., & Miller, D. L. (2011). Robust inference with multiway clustering. +- Cameron, A. C., Gelbach, J. B., & Miller, D. L. (2011). Robust inference with multiway clustering. \ No newline at end of file From df8f5c5028585f6360d3970a18af0240c6d23423 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 16:52:32 +0800 Subject: [PATCH 062/165] docs: sync Chinese panel diagnostic contracts --- docs/cn/models/panel.md | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) diff --git a/docs/cn/models/panel.md b/docs/cn/models/panel.md index 8f4b2f93e..61c596fc0 100644 --- a/docs/cn/models/panel.md +++ b/docs/cn/models/panel.md @@ -128,7 +128,7 @@ within/between/overall R² 采用与 `linearmodels` 对齐的 parameter-based - **between R²** 在个体均值上评价 \(\bar y_i-\bar X_i\hat\beta\)； - **within R²** 在 entity-demeaned 的 y 和 X 上评价同一系数向量。 -只有 level regressor design 中存在实际可识别的常数项时，overall 和 between total sum of squares 才中心化。固定效应本身不会自动改变这一规则。若 total sum of squares 为 0，Stage-B 标准字段返回 `0.0`，并在 `metadata["degenerate_total_ss"]` 中标记。 +只有 level regressor design 中存在实际可识别的常数项时，overall 和 between total sum of squares 才中心化。固定效应本身不会自动改变这一规则。`RandomEffects` 会检测传入 level design 中显式的非零常数列，并在 adjusted R² 与 restricted model-F 中保留其 quasi-demeaned transformed column。若 total sum of squares 为 0，Stage-B 标准字段返回 `0.0`，并在 `metadata["degenerate_total_ss"]` 中标记。 ### Legacy `PanelOLS.rsquared_within` @@ -140,7 +140,9 @@ within/between/overall R² 采用与 `linearmodels` 对齐的 parameter-based - 仅 entity effects：\(N\)； - 仅 time effects：\(T\)； -- entity + time effects：\(N+T-1\)。 +- entity + time effects：\(N+T-C\)，其中 \(C\) 是观测到的 entity-time incidence graph 的 connected-component 数。 + +因此常见的 \(N+T-1\) 只是连通面板 \(C=1\) 的特例；若 incomplete panel 的 incidence graph 不连通，diagnostic df 使用实际 dummy-space rank，而不会硬编码连通情形。 若 transformed slope design 的数值 rank 为 \(r_X\)，Stage B 使用 @@ -170,7 +172,7 @@ F= {RSS_U/\mathrm{df}_{\mathrm{resid}}}, $$ -其中 \(q\) 是有效 restriction rank。即使 estimator 的 coefficient covariance 使用 robust 或 clustered 选项，这一字段也不会静默变成 robust Wald test。 +其中 \(q\) 是有效 restriction rank。即使 estimator 的 coefficient covariance 使用 robust 或 clustered 选项，这一字段也不会静默变成 robust Wald test。当 unrestricted regression 精确拟合而 restricted regression 的 RSS 为正时，标准化结果采用经典极限值 `F=inf`、`p=0`，而不是把统计量标成 unavailable。 `FamaMacBeth` 不定义 residual-OLS model F 或 adjusted R²，因为其 covariance 来自逐期横截面系数时间序列；Stage B 不会把 beta-series inference 重命名成 residual OLS inference。 @@ -235,10 +237,12 @@ $$ - FE 必须只有 one-way entity effects； - FE coefficient covariance 必须是 classical/nonrobust； - FE 与 RE 必须来自同一个对齐后的 X/y/entity 样本和共同 slope design； -- 行/样本一致性使用紧凑的 backend-native numerical fingerprint 检查，而不是仅比较 shape； +- 行/样本一致性使用所有对齐 float64 X/y 值的 collision-resistant SHA-256 digest，并结合 entity-code signature 与 feature metadata，而不是只比较 shape 或低阶 moments； - intercept 不进入共同 slope 比较； - covariance difference 若实质上 indefinite，则返回 inapplicable，不通过 eigenvalue clipping 强行制造统计量。 +GPU 拟合下，full-content digest 仅为了 hashing 而通过有界 chunk 分批复制到 host；拟合对象只保存 digest 与紧凑 metadata，不保留第二份完整 CPU design copy。统计估计、covariance 构造与 fit-statistic reduction 仍在所选数值 backend 上完成。 + 若 covariance difference 为 positive semidefinite 但 rank deficient，statgpu 提供显式记录的 generalized-inverse extension：只在 coefficient difference 位于 identified range 内时计算，并使用 numerical rank 作为 chi-square df。metadata 会记录 `used_pinv=True` 和 `singular PSD generalized-inverse Hausman`。Stage B 不实现 robust auxiliary-regression Hausman。 ## 参数与 fit 签名 @@ -327,7 +331,7 @@ re = RandomEffects(device="cpu").fit(X, y, entity_ids=entity_ids) print(fe.hausman_test(re)) ``` -CuPy CUDA 使用 `device="cuda"`；Torch CUDA 使用 CUDA tensor 并设置 `device="torch"`。Stage-B sufficient-statistic accumulation 跟随所选数值 backend；只有紧凑 metadata、最终 scalar 与小型 covariance matrix 跨越 CPU metadata boundary。 +CuPy CUDA 使用 `device="cuda"`；Torch CUDA 使用 CUDA tensor 并设置 `device="torch"`。Stage-B 的统计变换与 sufficient-statistic accumulation 跟随所选数值 backend；formula/label metadata、最终 scalar 与小型 covariance matrix 使用 CPU metadata boundary；Hausman 还会仅为 full-content identity digest 对对齐 X/y 做有界分块 host copy。 ## 输出 @@ -344,7 +348,7 @@ CuPy CUDA 使用 `device="cuda"`；Torch CUDA 使用 CUDA tensor 并设置 `devi ## Formula 与元数据边界 -formula evaluation 可能因为 missing value 删除行。entity、time、cluster 等 side array 会与保留行同步对齐。字符串和分类标签在 CPU 上 factorize；数值变换与 sufficient-statistic calculation 继续留在所选 backend。Hausman 只保存紧凑 sample/design fingerprint 与小型 covariance matrix，不保存第二份完整 CPU design copy。 +formula evaluation 可能因为 missing value 删除行。entity、time、cluster 等 side array 会与保留行同步对齐。字符串和分类标签在 CPU 上 factorize；数值变换与 sufficient-statistic calculation 继续留在所选 backend。Hausman 会把对齐 X/y 以有界 chunk 复制到 host 计算 full-content SHA-256 identity，随后只保存 digest、feature/entity metadata 与小型 covariance matrix，不保存第二份完整 CPU design copy。 ## 验证 @@ -360,4 +364,4 @@ Stage B 增加 maintained analytic/fitted-model regression tests、formula/missi - White, H. (1980). A heteroskedasticity-consistent covariance matrix estimator. - Newey, W. K., & West, K. D. (1987). A simple, positive semi-definite, heteroskedasticity and autocorrelation consistent covariance matrix. - Fama, E. F., & MacBeth, J. D. (1973). Risk, return, and equilibrium. -- Cameron, A. C., Gelbach, J. B., & Miller, D. L. (2011). Robust inference with multiway clustering. +- Cameron, A. C., Gelbach, J. B., & Miller, D. L. (2011). Robust inference with multiway clustering. \ No newline at end of file From 8385a9e4393984c1a20d160425f1287174422f1c Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 16:54:29 +0800 Subject: [PATCH 063/165] test: align RandomEffects constant F structure externally --- dev/tests/test_panel_stage_b_linearmodels.py | 33 ++++++++++++++++++-- 1 file changed, 30 insertions(+), 3 deletions(-) diff --git a/dev/tests/test_panel_stage_b_linearmodels.py b/dev/tests/test_panel_stage_b_linearmodels.py index e1aa7af00..4d47da0be 100644 --- a/dev/tests/test_panel_stage_b_linearmodels.py +++ b/dev/tests/test_panel_stage_b_linearmodels.py @@ -4,7 +4,8 @@ compares only quantities whose estimator parameterizations and transformed samples are intentionally aligned in Stage B. RandomEffects coefficients are excluded because statgpu's existing Swamy-Arora path is a preserved -model-specific contract. +model-specific contract; for RandomEffects we compare only structural +diagnostic contracts that do not require coefficient equality. """ from __future__ import annotations @@ -24,9 +25,16 @@ FirstDifferenceOLS as LMFirstDifferenceOLS, PanelOLS as LMPanelOLS, PooledOLS as LMPooledOLS, + RandomEffects as LMRandomEffects, ) -from statgpu.panel import BetweenOLS, FirstDifferenceOLS, PanelOLS, PooledOLS +from statgpu.panel import ( + BetweenOLS, + FirstDifferenceOLS, + PanelOLS, + PooledOLS, + RandomEffects, +) def _panel(seed=1260, *, unbalanced=False): @@ -195,6 +203,25 @@ def test_pooled_and_between_match_linearmodels_on_general_unbalanced_panel(): _assert_model_f(sg_between.fit_statistics_, lm_between) +def test_random_effects_explicit_constant_matches_linearmodels_f_df_structure(): + X, y, entity, time = _panel(seed=1264, unbalanced=True) + y_lm, X_lm_const = _lm_data(X, y, entity, time, constant=True) + lm = LMRandomEffects(y_lm, X_lm_const).fit( + cov_type="unadjusted", debiased=True + ) + + X_const = np.column_stack([np.ones(X.shape[0]), X]) + sg = RandomEffects().fit(X_const, y, entity_ids=entity) + + assert sg.fit_statistics_.metadata["has_explicit_constant"] is True + assert sg.fit_statistics_.metadata["model_f"]["rank_restricted"] == 1 + assert sg.fit_statistics_.metadata["model_f"]["restricted_design_supplied"] is True + assert sg.fit_statistics_.f_df == ( + float(lm.f_statistic.df), + float(lm.f_statistic.df_denom), + ) + + def test_first_difference_matches_linearmodels_when_transformed_sample_is_common(): X, y, entity, time = _gap_free_unbalanced_panel() y_lm, X_lm = _lm_data(X, y, entity, time, constant=False) @@ -206,4 +233,4 @@ def test_first_difference_matches_linearmodels_when_transformed_sample_is_common ) assert_allclose(sg_fd.coef_, lm_fd.params.to_numpy(), rtol=2e-10, atol=2e-11) _assert_r2(sg_fd.fit_statistics_, lm_fd) - _assert_model_f(sg_fd.fit_statistics_, lm_fd) + _assert_model_f(sg_fd.fit_statistics_, lm_fd) \ No newline at end of file From 1d31d1932250f0eb07d4dba5f53aef58513b3f82 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 16:55:33 +0800 Subject: [PATCH 064/165] docs: correct normative panel diagnostic rank specification --- .../panel_p1_stage_b_diagnostics_df_addendum.md | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/dev/plans/panel_p1_stage_b_diagnostics_df_addendum.md b/dev/plans/panel_p1_stage_b_diagnostics_df_addendum.md index 0c73a8423..b6a8dd84e 100644 --- a/dev/plans/panel_p1_stage_b_diagnostics_df_addendum.md +++ b/dev/plans/panel_p1_stage_b_diagnostics_df_addendum.md @@ -12,7 +12,7 @@ df_resid_legacy = n - k - [(N - 1) entity effects] - [(T - 1) time effects] for the corresponding included effects. This quantity continues to drive the existing nonrobust/robust covariance, t statistics, p-values, and confidence intervals and **must not change in Stage B**. -The standard poolability/model-F definitions in `linearmodels`/`plm`, however, count the rank of the full fixed-effect nuisance space. With no explicit exogenous constant, a one-way entity FE model has nuisance-effect rank `N`; a two-way entity+time model has effect rank `N + T - 1`. In the ordinary full-rank case this makes the standard diagnostic residual df one lower than statgpu's legacy Stage-A inference df. +The standard poolability/model-F definitions in `linearmodels`/`plm`, however, count the rank of the full fixed-effect nuisance space. With no explicit exogenous constant, a one-way entity FE model has nuisance-effect rank `N`. For two-way entity+time effects, let `C` denote the number of connected components in the observed bipartite entity-time incidence graph; the full dummy-space rank is `N + T - C`. The familiar `N + T - 1` expression is therefore the connected-panel special case `C = 1`, not a valid formula for every incomplete panel. In the ordinary connected full-rank case this makes the standard diagnostic residual df one lower than statgpu's legacy Stage-A inference df. Therefore Stage B introduces an internal **standard diagnostic residual df** rather than changing `model.df_resid`. @@ -25,7 +25,7 @@ For current statgpu `PanelOLS`, formula intercepts are stripped before fitting a - no effects: `0`; - entity only: `N`; - time only: `T`; -- entity + time: `N + T - 1`. +- entity + time: `N + T - C`, where `C` is the connected-component count of the observed entity-time incidence graph. Then @@ -34,7 +34,7 @@ df_model_diag = r_x + effect_rank_standard df_resid_diag = n - df_model_diag ``` -The implementation stores these values only in Stage-B diagnostic metadata/internal context. It does not overwrite the Stage-A `df_resid` attribute. +The implementation stores these values only in Stage-B diagnostic metadata/internal context. It does not overwrite the Stage-A `df_resid` attribute. For two-way FE it also records the incidence-component count so the rank decision is auditable. The primary transformed FE response lives in the orthogonal complement of the nuisance-effect space, so the corresponding total-variation degrees of freedom for Stage-B adjusted R² are @@ -85,7 +85,7 @@ df_num = df_pool_diag - df_resid_diag_FE F = ((RSS_pool - RSS_FE) / df_num) / (RSS_FE / df_resid_diag_FE) ``` -This is equivalent to the external effect-rank formulation in the ordinary full-rank case and remains auditable under rank deficiency. +This is equivalent to the external effect-rank formulation in the ordinary full-rank case and remains auditable under rank deficiency and disconnected two-way incidence graphs. Roundoff/material nesting-failure behavior from the main plan remains unchanged. @@ -95,8 +95,12 @@ For standardized parameter-based **overall** and **between** R², centering depe The common-constant projection used by the **pooling F test** is a separate nested-test construction and must not be reused as a general R² centering rule. +For `RandomEffects`, an explicit nonzero constant column in the supplied level design is detected directly. The quasi-demeaned transformed version of that same column is retained as the restricted intercept design for adjusted R² and classical model F, including on unbalanced panels where the transformed intercept is not a vector of ones. + ## Review status - **[HIGH][INFER] fixed in specification** — Stage-B poolability/model-F inference will no longer reuse a legacy FE residual df that differs from the standard nuisance-effect rank convention. -- **[MEDIUM][INFER] fixed in specification** — FE adjusted R² now uses nuisance-rank-consistent total df rather than provisional `n-1`. +- **[HIGH][INFER] fixed after review** — two-way FE nuisance rank now uses the observed incidence-graph component count (`N + T - C`) instead of assuming every incomplete panel is connected. +- **[MEDIUM][INFER] fixed in specification** — FE adjusted R² uses nuisance-rank-consistent total df rather than provisional `n-1`. - **[MEDIUM][INFER] fixed in specification** — overall/between R² centering is explicitly separated from the pooling-F common-constant correction. +- **[MEDIUM][INFER] fixed after review** — RandomEffects explicit-constant diagnostics retain the transformed intercept in the restricted fit-space definition. From 9d5ee4c66d69418d301abd2c53bda5310c13be2c Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 16:57:42 +0800 Subject: [PATCH 065/165] docs: make post-review panel contracts normative --- ...anel_p1_stage_b_diagnostics_df_addendum.md | 38 +++++++++++++++++-- 1 file changed, 35 insertions(+), 3 deletions(-) diff --git a/dev/plans/panel_p1_stage_b_diagnostics_df_addendum.md b/dev/plans/panel_p1_stage_b_diagnostics_df_addendum.md index b6a8dd84e..ba426e26b 100644 --- a/dev/plans/panel_p1_stage_b_diagnostics_df_addendum.md +++ b/dev/plans/panel_p1_stage_b_diagnostics_df_addendum.md @@ -1,6 +1,6 @@ # Panel Stage B diagnostic-df addendum -This addendum is normative for `panel_p1_stage_b_diagnostics_plan.md` and closes second-round definition issues discovered immediately before estimator integration. +This addendum is normative for `panel_p1_stage_b_diagnostics_plan.md` and closes second-round definition issues discovered immediately before estimator integration. Where this addendum explicitly overrides a conflicting clause in the main plan, the addendum is the final Stage-B contract. ## Why a separate diagnostic df is required @@ -97,10 +97,42 @@ The common-constant projection used by the **pooling F test** is a separate nest For `RandomEffects`, an explicit nonzero constant column in the supplied level design is detected directly. The quasi-demeaned transformed version of that same column is retained as the restricted intercept design for adjusted R² and classical model F, including on unbalanced panels where the transformed intercept is not a vector of ones. +## Normative post-review overrides + +Final PR review exposed additional correctness boundaries that supersede conflicting early-plan wording in Sections 5.1--5.3, 5.5, 6, 7, and 12 of `panel_p1_stage_b_diagnostics_plan.md`. + +### Hausman sample/design identity + +The earlier O(k) low-order-moment fingerprint is retained only as optional audit metadata; it is **not** sufficient proof that FE and RE used the same aligned numerical sample. Distinct row sequences can share sums, sums of squares, and index-weighted first moments. + +The authoritative Stage-B identity contract is: + +- compute a versioned SHA-256 digest over **every aligned float64 X/y value in row order**, including shape framing; +- compare the digest together with feature-name/intercept metadata and a separate aligned entity-code signature; +- require exact digest equality rather than an `allclose` tolerance for identity; +- on CuPy/Torch fits, transfer X/y to host in bounded chunks solely for hashing; no single extra full-design host allocation is required; +- persist only the digest and compact metadata after hashing, never a second retained CPU copy of the full design. + +This bounded hashing transfer is an explicit exception to the early-plan statement that Hausman may transfer only O(k) fingerprint scalars. The statistical estimation, covariance construction, and fit-statistic reductions remain backend-native; the exception exists only to make the identity check collision-resistant. + +### Classical model-F exact-fit boundary + +The early generic “unavailable when unrestricted RSS is zero” wording is too coarse. The final Stage-B contract is: + +- if unrestricted RSS is numerically zero and restricted RSS is materially positive, report the limiting classical result `F = inf`, `p = 0`, with the ordinary numerator/denominator df; +- if both restricted and unrestricted RSS are numerically zero, the joint-slope statistic is indeterminate and remains unavailable with an explicit reason; +- material nesting violations remain inapplicable rather than being silently clipped. + +### RandomEffects explicit constant + +`RandomEffects` must detect an actual nonzero constant column in the supplied level design. Because Swamy-Arora quasi-demeaning transforms that column and an unbalanced panel generally does not leave a vector of ones, the transformed constant column itself is the restricted design for adjusted R²/model-F accounting. No implicit intercept is invented when the level design has none. + ## Review status -- **[HIGH][INFER] fixed in specification** — Stage-B poolability/model-F inference will no longer reuse a legacy FE residual df that differs from the standard nuisance-effect rank convention. -- **[HIGH][INFER] fixed after review** — two-way FE nuisance rank now uses the observed incidence-graph component count (`N + T - C`) instead of assuming every incomplete panel is connected. +- **[HIGH][INFER] fixed in specification** — Stage-B poolability/model-F inference no longer reuses a legacy FE residual df that differs from the standard nuisance-effect rank convention. +- **[HIGH][INFER] fixed after review** — two-way FE nuisance rank uses the observed incidence-graph component count (`N + T - C`) instead of assuming every incomplete panel is connected. +- **[HIGH][API/INFER] fixed after review** — Hausman identity uses a collision-resistant full-content digest; low-order moments alone are no longer accepted as proof of sample identity. - **[MEDIUM][INFER] fixed in specification** — FE adjusted R² uses nuisance-rank-consistent total df rather than provisional `n-1`. - **[MEDIUM][INFER] fixed in specification** — overall/between R² centering is explicitly separated from the pooling-F common-constant correction. - **[MEDIUM][INFER] fixed after review** — RandomEffects explicit-constant diagnostics retain the transformed intercept in the restricted fit-space definition. +- **[MEDIUM][INFER] fixed after review** — exact unrestricted fits with a nonzero restricted RSS report `F=inf, p=0` instead of being discarded as unavailable. From 3f92a0a78b0690caee0eb1882590e8d7fbf27270 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 20:25:13 +0800 Subject: [PATCH 066/165] fix: make panel diagnostic tolerances scale invariant --- statgpu/panel/_diagnostics.py | 53 +++++++++++++++++++++++++---------- 1 file changed, 38 insertions(+), 15 deletions(-) diff --git a/statgpu/panel/_diagnostics.py b/statgpu/panel/_diagnostics.py index e579bb26a..1a6683418 100644 --- a/statgpu/panel/_diagnostics.py +++ b/statgpu/panel/_diagnostics.py @@ -76,6 +76,19 @@ def _matrix_rank(X, xp) -> int: return int(_to_float_scalar(xp.linalg.matrix_rank(X))) +def _relative_tolerance(*values: float, factor: float = 256.0) -> float: + """Return a float64 roundoff tolerance that preserves scale equivariance. + + Statistical quantities such as RSS and covariance matrices have physical + scale. Using an absolute ``max(1, scale)`` floor makes F/Hausman decisions + depend on the arbitrary units of y or beta. A zero scale therefore maps to + an exact zero tolerance; otherwise the tolerance scales linearly with the + compared quantity. + """ + scale = max((abs(float(value)) for value in values), default=0.0) + return float(factor) * np.finfo(np.float64).eps * scale + + def _safe_r2(ss_res: float, ss_tot: float) -> Tuple[float, bool]: """Return linearmodels-style parameter R² and a degenerate-TSS flag.""" ss_res = float(ss_res) @@ -212,7 +225,7 @@ def _classical_model_f( rss_r = _to_float_scalar(xp.sum(y * y)) diff = rss_r - rss_u - tol = 256.0 * np.finfo(np.float64).eps * max(1.0, abs(rss_r), abs(rss_u)) + tol = _relative_tolerance(rss_r, rss_u) if diff < -tol: metadata["unavailable_reason"] = "restricted RSS is materially below unrestricted RSS" metadata["rss_restricted"] = float(rss_r) @@ -338,32 +351,42 @@ def _pooling_f_from_sums( reason="pooling F requires positive numerator and denominator degrees of freedom", metadata=meta, ) - if float(rss_effects) <= 0.0: + + diff = float(rss_pooled) - float(rss_effects) + tol = _relative_tolerance(rss_pooled, rss_effects) + if diff < -tol: return _inapplicable( null=null, alternative=alternative, distribution="F", df=(float(df_num), float(df_denom)), - reason="fixed-effects residual sum of squares must be positive", + reason="pooled RSS is materially below fixed-effects RSS; nested-model contract failed", metadata=meta, ) + if diff < 0.0: + diff = 0.0 + meta["roundoff_normalized"] = True - diff = float(rss_pooled) - float(rss_effects) - tol = 256.0 * np.finfo(np.float64).eps * max( - 1.0, abs(float(rss_pooled)), abs(float(rss_effects)) - ) - if diff < -tol: + if float(rss_effects) <= tol: + if diff > tol: + meta["exact_fit"] = True + return _applicable( + float("inf"), + 0.0, + null=null, + alternative=alternative, + distribution="F", + df=(float(df_num), float(df_denom)), + metadata=meta, + ) return _inapplicable( null=null, alternative=alternative, distribution="F", df=(float(df_num), float(df_denom)), - reason="pooled RSS is materially below fixed-effects RSS; nested-model contract failed", + reason="pooled and fixed-effects residual sums of squares are both zero", metadata=meta, ) - if diff < 0.0: - diff = 0.0 - meta["roundoff_normalized"] = True statistic = (diff / int(df_num)) / (float(rss_effects) / int(df_denom)) dist = get_distribution("f", backend="numpy") @@ -465,7 +488,7 @@ def _hausman_quadratic( D = 0.5 * (D + D.T) eigvals, eigvecs = np.linalg.eigh(D) norm_D = float(np.linalg.norm(D, ord=2)) if D.size else 0.0 - tol = 256.0 * np.finfo(np.float64).eps * max(1.0, norm_D) * max(1, d.size) + tol = _relative_tolerance(norm_D, factor=256.0 * max(1, d.size)) meta = { "eigen_tolerance": tol, "minimum_eigenvalue": float(eigvals.min()), @@ -496,7 +519,7 @@ def _hausman_quadratic( basis = eigvecs[:, positive] projected = basis @ (basis.T @ d) null_component = d - projected - range_tol = 1024.0 * np.finfo(np.float64).eps * max(1.0, np.linalg.norm(d)) + range_tol = _relative_tolerance(np.linalg.norm(d), factor=1024.0) meta["range_tolerance"] = float(range_tol) meta["nullspace_component_norm"] = float(np.linalg.norm(null_component)) if float(np.linalg.norm(null_component)) > range_tol: @@ -791,4 +814,4 @@ def hausman_test(fe_model, re_model) -> PanelTestResult: applicable=result.applicable, reason=result.reason, metadata=meta, - ) \ No newline at end of file + ) From 3dc25f78abcb5ca6a4841ac5ac8ed4f016b76dd3 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 20:27:32 +0800 Subject: [PATCH 067/165] fix: make explicit constant detection scale invariant --- statgpu/panel/_diagnostic_context.py | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/statgpu/panel/_diagnostic_context.py b/statgpu/panel/_diagnostic_context.py index e069055ea..a065bb25f 100644 --- a/statgpu/panel/_diagnostic_context.py +++ b/statgpu/panel/_diagnostic_context.py @@ -160,7 +160,12 @@ def fixed_effect_diagnostic_df( def explicit_constant_column(X, *, xp): - """Return an identified explicit constant-column index, if one is present.""" + """Return an identified explicit constant-column index, if one is present. + + The classification is relative to each column's own magnitude so multiplying + a valid design column by a nonzero unit-conversion factor does not change + whether it is recognized as an explicit constant. + """ if int(X.shape[1]) == 0: return None if getattr(xp, "__name__", "") == "torch": @@ -171,11 +176,10 @@ def explicit_constant_column(X, *, xp): max_native = xp.max(X, axis=0) col_min = np.asarray(_to_numpy(min_native), dtype=np.float64).ravel() col_max = np.asarray(_to_numpy(max_native), dtype=np.float64).ravel() - scale = np.maximum(1.0, np.maximum(np.abs(col_min), np.abs(col_max))) - tol = 256.0 * np.finfo(np.float64).eps * scale - span = np.abs(col_max - col_min) magnitude = np.maximum(np.abs(col_min), np.abs(col_max)) - candidates = np.flatnonzero((span <= tol) & (magnitude > tol)) + tol = 256.0 * np.finfo(np.float64).eps * magnitude + span = np.abs(col_max - col_min) + candidates = np.flatnonzero((span <= tol) & (magnitude > 0.0)) if candidates.size == 0: return None return int(candidates[0]) From b89968a1903201b688db97fee91c9fb888e8ed9e Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 20:28:05 +0800 Subject: [PATCH 068/165] test: cover scale-invariant panel diagnostics --- .../test_panel_stage_b_review_regressions.py | 97 ++++++++++++++++++- 1 file changed, 96 insertions(+), 1 deletion(-) diff --git a/dev/tests/test_panel_stage_b_review_regressions.py b/dev/tests/test_panel_stage_b_review_regressions.py index 138a75409..3c37b3816 100644 --- a/dev/tests/test_panel_stage_b_review_regressions.py +++ b/dev/tests/test_panel_stage_b_review_regressions.py @@ -6,11 +6,16 @@ from numpy.testing import assert_allclose from statgpu.panel import RandomEffects -from statgpu.panel._diagnostic_context import fixed_effect_diagnostic_df +from statgpu.panel._diagnostic_context import ( + explicit_constant_column, + fixed_effect_diagnostic_df, +) from statgpu.panel._diagnostics import ( _classical_model_f, _diagnostic_identity, _fingerprints_match, + _hausman_quadratic, + _pooling_f_from_sums, ) @@ -95,6 +100,96 @@ def test_classical_model_f_reports_infinite_statistic_for_exact_fit(): assert metadata["rss_unrestricted"] <= metadata["rss_restricted"] +def test_classical_model_f_is_invariant_to_response_units(): + x = np.linspace(-1.0, 1.0, 12) + X = np.column_stack([np.ones(x.size), x]) + y = 0.8 + 0.45 * x + np.asarray( + [0.08, -0.04, 0.03, -0.06, 0.05, -0.02, 0.01, 0.04, -0.03, 0.02, -0.01, 0.05] + ) + params = np.linalg.lstsq(X, y, rcond=None)[0] + df_resid = x.size - np.linalg.matrix_rank(X) + + reference = _classical_model_f( + y, + X, + params, + xp=np, + df_resid=df_resid, + has_constant=True, + ) + assert reference[0] is not None and np.isfinite(reference[0]) + + for scale in (1e-8, 1e-12): + candidate = _classical_model_f( + scale * y, + X, + scale * params, + xp=np, + df_resid=df_resid, + has_constant=True, + ) + assert candidate[0] is not None and np.isfinite(candidate[0]) + assert_allclose(candidate[0], reference[0], rtol=1e-10, atol=1e-12) + assert_allclose(candidate[1], reference[1], rtol=1e-10, atol=1e-14) + assert candidate[2] == reference[2] + + +def test_hausman_quadratic_is_invariant_to_parameter_units(): + difference = np.asarray([0.2, -0.1]) + covariance_difference = np.asarray([[0.04, 0.01], [0.01, 0.09]]) + reference = _hausman_quadratic(difference, covariance_difference) + assert reference.applicable + + for scale in (1e-8, 1e-12): + candidate = _hausman_quadratic( + scale * difference, + (scale * scale) * covariance_difference, + ) + assert candidate.applicable + assert candidate.df == reference.df + assert_allclose(candidate.statistic, reference.statistic, rtol=1e-10, atol=1e-12) + assert_allclose(candidate.pvalue, reference.pvalue, rtol=1e-10, atol=1e-14) + + +def test_explicit_constant_detection_is_invariant_to_column_units(): + slope = np.linspace(-1.0, 1.0, 9) + for scale in (1.0, 1e-8, 1e-12): + X = np.column_stack([np.full(slope.size, scale), slope]) + assert explicit_constant_column(X, xp=np) == 0 + + zero_column = np.column_stack([np.zeros(slope.size), slope]) + assert explicit_constant_column(zero_column, xp=np) is None + + +def test_pooling_f_reports_infinite_statistic_for_exact_effect_fit(): + result = _pooling_f_from_sums( + rss_pooled=4.0, + rss_effects=0.0, + df_num=3, + df_denom=10, + ) + + assert result.applicable + assert np.isinf(result.statistic) + assert result.pvalue == 0.0 + assert result.df == (3.0, 10.0) + assert result.metadata["exact_fit"] is True + + +def test_pooling_f_both_exact_models_remains_inapplicable(): + result = _pooling_f_from_sums( + rss_pooled=0.0, + rss_effects=0.0, + df_num=3, + df_denom=10, + ) + + assert not result.applicable + assert result.statistic is None + assert result.pvalue is None + assert "both zero" in result.reason + + def test_random_effects_explicit_constant_uses_constant_aware_diagnostics(): rng = np.random.default_rng(20260808) counts = np.asarray([5, 4, 3, 5, 4, 3]) From 8ead69d35e13d86807b9490a23cf9bf2dc63c3d9 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 20:29:03 +0800 Subject: [PATCH 069/165] test: cover explicit-constant RE on physical GPU --- dev/benchmarks/validate_panel_stage_b_gpu.py | 33 ++++++++++++++++++++ 1 file changed, 33 insertions(+) diff --git a/dev/benchmarks/validate_panel_stage_b_gpu.py b/dev/benchmarks/validate_panel_stage_b_gpu.py index 6384d5676..32d9338ed 100644 --- a/dev/benchmarks/validate_panel_stage_b_gpu.py +++ b/dev/benchmarks/validate_panel_stage_b_gpu.py @@ -150,6 +150,18 @@ def _model_snapshot(model): payload["pooling_f"] = _test_result(model.pooling_f_test()) if hasattr(model, "breusch_pagan_lm_test") and isinstance(model, PooledOLS): payload["bp_lm"] = _test_result(model.breusch_pagan_lm_test()) + if isinstance(model, RandomEffects): + meta = model.fit_statistics_.metadata + model_f_meta = meta.get("model_f", {}) + payload["random_effects_diagnostic_contract"] = { + "has_explicit_constant": bool(meta.get("has_explicit_constant")), + "constant_column_index": meta.get("constant_column_index"), + "restricted_rank": int(meta.get("restricted_rank", 0)), + "model_f_rank_restricted": int(model_f_meta.get("rank_restricted", 0)), + "model_f_restricted_design_supplied": bool( + model_f_meta.get("restricted_design_supplied", False) + ), + } return payload @@ -201,6 +213,16 @@ def _fit_cases(X, y, entity, time, backend, *, unbalanced): re = RandomEffects(device=device).fit(Xb, yb, entity_ids=eb) cases[f"random_effects_{suffix}"] = re + # Exercise the explicit-constant RandomEffects branch on the physical GPU. + # This is intentionally a separate case so the no-intercept Stage-A path + # remains independently frozen by the ordinary RandomEffects case above. + X_constant = np.column_stack([np.ones(X.shape[0]), X[:, 0]]) + Xcb, ycb, ecb, _ = _to_backend_arrays( + X_constant, y, entity, time, backend + ) + re_constant = RandomEffects(device=device).fit(Xcb, ycb, entity_ids=ecb) + cases[f"random_effects_explicit_constant_{suffix}"] = re_constant + fmb = FamaMacBeth(cov_type="newey-west", bandwidth=2, device=device).fit( Xb, yb, @@ -323,6 +345,17 @@ def _compare_model(reference, candidate, *, rtol, atol, label): reference["diagnostic_covariance"], ) + if "random_effects_diagnostic_contract" in reference: + if candidate.get("random_effects_diagnostic_contract") != reference[ + "random_effects_diagnostic_contract" + ]: + raise AssertionError( + f"{label}.random_effects_diagnostic_contract mismatch: " + f"{candidate.get('random_effects_diagnostic_contract')} != " + f"{reference['random_effects_diagnostic_contract']}" + ) + differences["random_effects_diagnostic_contract"] = 0.0 + for test_name in ("pooling_f", "bp_lm"): if test_name in reference: nested = _compare_test_result( From 40053e19077d997ce0a22b67f45aa80bad0d8827 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 20:30:26 +0800 Subject: [PATCH 070/165] bench: measure Panel Hausman identity overhead --- ...nchmark_panel_stage_b_identity_overhead.py | 246 ++++++++++++++++++ 1 file changed, 246 insertions(+) create mode 100644 dev/benchmarks/benchmark_panel_stage_b_identity_overhead.py diff --git a/dev/benchmarks/benchmark_panel_stage_b_identity_overhead.py b/dev/benchmarks/benchmark_panel_stage_b_identity_overhead.py new file mode 100644 index 000000000..9b9ee7ef1 --- /dev/null +++ b/dev/benchmarks/benchmark_panel_stage_b_identity_overhead.py @@ -0,0 +1,246 @@ +#!/usr/bin/env python3 +"""Measure Stage-B full-content identity overhead on physical GPU backends. + +This benchmark isolates the cost of the collision-resistant X/y SHA-256 used by +Hausman sample identity. It compares ordinary PanelOLS/RandomEffects fit time +against the same fit with only ``_full_content_digest`` replaced by a constant +stub. Numerical work, low-order audit reductions, estimator setup, and all other +Stage-B code remain unchanged in the baseline. + +The script is intentionally separate from ``validate_panel_stage_b_gpu.py``: +that runner remains correctness/provenance-only and its frontend source must not +acquire inferred timing or speedup fields. +""" + +from __future__ import annotations + +import argparse +import importlib.metadata +import json +import platform +import subprocess +import time +from pathlib import Path + +import numpy as np + +import statgpu.panel._diagnostics as diagnostics +from statgpu.panel import PanelOLS, RandomEffects + + +def _git_sha() -> str: + return subprocess.check_output(["git", "rev-parse", "HEAD"], text=True).strip() + + +def _git_status_porcelain() -> str: + return subprocess.check_output(["git", "status", "--porcelain"], text=True) + + +def _version(name: str): + try: + return importlib.metadata.version(name) + except importlib.metadata.PackageNotFoundError: + return None + + +def _parse_scales(value: str): + out = [] + for item in value.split(","): + n_text, k_text = item.strip().lower().split("x", 1) + n, k = int(n_text), int(k_text) + if n <= 0 or k <= 0: + raise ValueError("benchmark scales must be positive NxK pairs") + out.append((n, k)) + return out + + +def _sync(backend: str): + if backend == "cupy": + import cupy as cp + + cp.cuda.Stream.null.synchronize() + elif backend == "torch": + import torch + + torch.cuda.synchronize() + + +def _to_backend(X, y, entity, backend: str): + if backend == "cupy": + import cupy as cp + + return ( + cp.asarray(X), + cp.asarray(y), + cp.asarray(entity, dtype=cp.int64), + ) + if backend == "torch": + import torch + + return ( + torch.as_tensor(X, dtype=torch.float64, device="cuda"), + torch.as_tensor(y, dtype=torch.float64, device="cuda"), + torch.as_tensor(entity, dtype=torch.int64, device="cuda"), + ) + raise ValueError(backend) + + +def _device_arg(backend: str): + return {"cupy": "cuda", "torch": "torch"}[backend] + + +def _dataset(n: int, k: int, seed: int): + rng = np.random.default_rng(seed) + X = rng.normal(size=(n, k)).astype(np.float64) + beta = np.linspace(0.2, 0.8, k, dtype=np.float64) + entity = np.arange(n, dtype=np.int64) // 20 + n_entities = int(entity.max()) + 1 + alpha = np.linspace(-0.5, 0.5, n_entities, dtype=np.float64)[entity] + y = X @ beta + alpha + rng.normal(scale=0.2, size=n) + return X, y.astype(np.float64), entity + + +def _fit(model_name: str, X, y, entity, backend: str): + device = _device_arg(backend) + if model_name == "PanelOLS": + model = PanelOLS(entity_effects=True, cov_type="nonrobust", device=device) + elif model_name == "RandomEffects": + model = RandomEffects(device=device) + else: + raise ValueError(model_name) + model.fit(X, y, entity_ids=entity) + return model + + +def _timed_fit(model_name, X, y, entity, backend, *, disable_digest: bool): + original = diagnostics._full_content_digest + if disable_digest: + diagnostics._full_content_digest = lambda _X, _y: "0" * 64 + try: + _sync(backend) + start = time.perf_counter() + _fit(model_name, X, y, entity, backend) + _sync(backend) + return time.perf_counter() - start + finally: + diagnostics._full_content_digest = original + + +def _median(values): + return float(np.median(np.asarray(values, dtype=np.float64))) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--out", type=Path, required=True) + parser.add_argument("--expected-sha", required=True) + parser.add_argument("--backends", default="cupy,torch") + parser.add_argument( + "--scales", + default="10000x2,100000x2,100000x10,500000x2", + help="comma-separated NxK pairs", + ) + parser.add_argument("--repeats", type=int, default=3) + args = parser.parse_args() + + sha = _git_sha() + if sha != args.expected_sha: + raise RuntimeError(f"wrong source head: {sha} != {args.expected_sha}") + dirty = _git_status_porcelain() + if dirty.strip(): + raise RuntimeError( + "identity benchmark requires a clean working tree; uncommitted changes:\n" + + dirty + ) + if args.repeats < 1: + raise ValueError("--repeats must be positive") + + backends = [x.strip() for x in args.backends.split(",") if x.strip()] + if not backends or any(x not in {"cupy", "torch"} for x in backends): + raise ValueError("--backends must contain cupy and/or torch") + scales = _parse_scales(args.scales) + + rows = [] + for scale_index, (n, k) in enumerate(scales): + X_np, y_np, entity_np = _dataset(n, k, seed=20260808 + scale_index) + for backend in backends: + X, y, entity = _to_backend(X_np, y_np, entity_np, backend) + for model_name in ("PanelOLS", "RandomEffects"): + # Warm both paths before measurement to avoid one-time import/ + # allocator effects being attributed to the digest. + _timed_fit( + model_name, X, y, entity, backend, disable_digest=False + ) + _timed_fit( + model_name, X, y, entity, backend, disable_digest=True + ) + + with_digest = [] + without_digest = [] + for _ in range(args.repeats): + with_digest.append( + _timed_fit( + model_name, + X, + y, + entity, + backend, + disable_digest=False, + ) + ) + without_digest.append( + _timed_fit( + model_name, + X, + y, + entity, + backend, + disable_digest=True, + ) + ) + + normal = _median(with_digest) + baseline = _median(without_digest) + overhead = normal - baseline + ratio = normal / baseline if baseline > 0.0 else None + rows.append( + { + "backend": backend, + "model": model_name, + "n_samples": n, + "n_features": k, + "repeats": args.repeats, + "with_digest_seconds": normal, + "without_digest_seconds": baseline, + "digest_overhead_seconds": overhead, + "with_over_without_ratio": ratio, + "with_digest_samples": with_digest, + "without_digest_samples": without_digest, + } + ) + + payload = { + "schema_version": 1, + "git_sha": sha, + "working_tree_clean": True, + "benchmark": "panel_stage_b_full_content_identity_overhead", + "timing_scope": "end-to-end estimator fit with vs without only the SHA-256 full-content digest", + "target_scale_source": "PR122 fresh-review performance finding", + "environment": { + "python": platform.python_version(), + "platform": platform.platform(), + "packages": { + name: _version(name) + for name in ("statgpu", "numpy", "cupy", "torch") + }, + }, + "rows": rows, + } + args.out.parent.mkdir(parents=True, exist_ok=True) + args.out.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8") + print(json.dumps(payload, indent=2)) + print(f"PASS — identity-overhead benchmark recorded: {args.out}") + + +if __name__ == "__main__": + main() From 73d1bcc0d20dd9093bdfdfda5b51435d5a7a7929 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 20:31:13 +0800 Subject: [PATCH 071/165] test: cover tiny explicit constants on Torch CPU --- dev/tests/test_panel_stage_b_torch_cpu.py | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/dev/tests/test_panel_stage_b_torch_cpu.py b/dev/tests/test_panel_stage_b_torch_cpu.py index 9e32d2368..0a290efaf 100644 --- a/dev/tests/test_panel_stage_b_torch_cpu.py +++ b/dev/tests/test_panel_stage_b_torch_cpu.py @@ -7,6 +7,7 @@ from numpy.testing import assert_allclose from statgpu.panel import FamaMacBeth, PanelOLS, PooledOLS, RandomEffects +from statgpu.panel._diagnostic_context import explicit_constant_column torch = pytest.importorskip("torch") @@ -169,6 +170,16 @@ def test_stage_b_random_effects_explicit_constant_torch_cpu_matches_numpy(): ) +def test_stage_b_torch_constant_detection_is_scale_invariant(): + slope = torch.linspace(-1.0, 1.0, 9, dtype=torch.float64) + for scale in (1.0, 1e-8, 1e-12): + X = torch.stack( + [torch.full_like(slope, scale), slope], + dim=1, + ) + assert explicit_constant_column(X, xp=torch) == 0 + + def test_stage_b_fama_macbeth_torch_cpu_r2_matches_numpy_without_ols_f(): X, y, entity, time = _panel(seed=1223) X_t, y_t, entity_t, time_t = _torch_arrays(X, y, entity, time) From 0864c3c48f00921f888690f48519795de31b6757 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 20:32:26 +0800 Subject: [PATCH 072/165] perf: skip Hausman digest for inapplicable FE fits --- statgpu/panel/_fixed_effects.py | 29 +++++++++++++++++++++-------- 1 file changed, 21 insertions(+), 8 deletions(-) diff --git a/statgpu/panel/_fixed_effects.py b/statgpu/panel/_fixed_effects.py index eedf2d5d9..f213fd7ce 100644 --- a/statgpu/panel/_fixed_effects.py +++ b/statgpu/panel/_fixed_effects.py @@ -311,13 +311,26 @@ def fit( "legacy_rsquared_within": float(self.rsquared_within), }, ) - self._panel_diagnostic_identity = build_diagnostic_identity( - X_arr, - y_arr, - xp=xp, - entity_codes=entity_arr, - feature_names=self._feature_names, - has_constant=False, + # Full-content identity is only needed for the Stage-B Hausman domain: + # one-way entity FE with classical nonrobust covariance. Robust, + # clustered, time-only, and two-way FE are rejected before identity + # comparison, so hashing their full X/y would be pure host-transfer cost. + hausman_compatible = ( + bool(self.entity_effects) + and not bool(self.time_effects) + and str(self._cov_type).lower() == "nonrobust" + ) + self._panel_diagnostic_identity = ( + build_diagnostic_identity( + X_arr, + y_arr, + xp=xp, + entity_codes=entity_arr, + feature_names=self._feature_names, + has_constant=False, + ) + if hausman_compatible + else None ) self._pooling_f_result = ( pooling_f_from_level_arrays( @@ -407,4 +420,4 @@ def set_params(self, **params): return super().set_params(**params) -FixedEffects = PanelOLS \ No newline at end of file +FixedEffects = PanelOLS From 3ac2eb1b0e8af358f6c20767b651541d4246ae5f Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 20:33:25 +0800 Subject: [PATCH 073/165] test: freeze Hausman digest eligibility --- .../test_panel_stage_b_review_regressions.py | 32 ++++++++++++++++--- 1 file changed, 27 insertions(+), 5 deletions(-) diff --git a/dev/tests/test_panel_stage_b_review_regressions.py b/dev/tests/test_panel_stage_b_review_regressions.py index 3c37b3816..c3b0c9453 100644 --- a/dev/tests/test_panel_stage_b_review_regressions.py +++ b/dev/tests/test_panel_stage_b_review_regressions.py @@ -5,7 +5,7 @@ import numpy as np from numpy.testing import assert_allclose -from statgpu.panel import RandomEffects +from statgpu.panel import PanelOLS, RandomEffects from statgpu.panel._diagnostic_context import ( explicit_constant_column, fixed_effect_diagnostic_df, @@ -20,8 +20,6 @@ def test_two_way_effect_rank_counts_disconnected_incidence_components(): - # Two disconnected incidence components: - # {entities 0,1} x {times 0,1} and {entities 2,3} x {times 2,3}. entity = np.asarray([0, 0, 1, 1, 2, 2, 3, 3], dtype=np.int64) time = np.asarray([0, 1, 0, 1, 2, 3, 2, 3], dtype=np.int64) X_transformed = np.arange(1.0, 9.0).reshape(-1, 1) @@ -46,8 +44,6 @@ def test_two_way_effect_rank_counts_disconnected_incidence_components(): def test_hausman_identity_rejects_low_order_moment_collision(): - # These response vectors have the same sum, sum of squares, and - # row-weighted sum. The previous low-order fingerprint therefore collided. y_left = np.asarray([0.0, 1.0, 3.0, 2.0]) y_right = np.asarray([0.0, 2.0, 1.0, 3.0]) X = np.asarray( @@ -232,3 +228,29 @@ def test_random_effects_without_constant_preserves_uncentered_diagnostic_basis() assert result.metadata["restricted_rank"] == 0 assert result.metadata["model_f"].get("restricted_design_supplied") is None assert result.metadata["model_f"]["rank_restricted"] == 0 + + +def test_fe_full_content_identity_only_for_hausman_compatible_fits(): + rng = np.random.default_rng(20260810) + entity = np.repeat(np.arange(6), 4) + time = np.tile(np.arange(4), 6) + X = rng.normal(size=(entity.size, 2)) + y = X @ np.asarray([0.6, -0.25]) + np.repeat( + np.linspace(-0.4, 0.5, 6), 4 + ) + rng.normal(scale=0.1, size=entity.size) + + classical = PanelOLS(entity_effects=True, cov_type="nonrobust").fit( + X, y, entity_ids=entity + ) + robust = PanelOLS(entity_effects=True, cov_type="robust").fit( + X, y, entity_ids=entity + ) + two_way = PanelOLS( + entity_effects=True, + time_effects=True, + cov_type="nonrobust", + ).fit(X, y, entity_ids=entity, time_ids=time) + + assert isinstance(classical._panel_diagnostic_identity, dict) + assert robust._panel_diagnostic_identity is None + assert two_way._panel_diagnostic_identity is None From a78b9cd08445c4f1e541baa619097ad670ea693b Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 20:34:20 +0800 Subject: [PATCH 074/165] docs: record final panel numerical boundary contracts --- ...anel_p1_stage_b_diagnostics_df_addendum.md | 26 ++++++++++++++++++- 1 file changed, 25 insertions(+), 1 deletion(-) diff --git a/dev/plans/panel_p1_stage_b_diagnostics_df_addendum.md b/dev/plans/panel_p1_stage_b_diagnostics_df_addendum.md index ba426e26b..666690051 100644 --- a/dev/plans/panel_p1_stage_b_diagnostics_df_addendum.md +++ b/dev/plans/panel_p1_stage_b_diagnostics_df_addendum.md @@ -87,7 +87,11 @@ F = ((RSS_pool - RSS_FE) / df_num) / (RSS_FE / df_resid_diag_FE) This is equivalent to the external effect-rank formulation in the ordinary full-rank case and remains auditable under rank deficiency and disconnected two-way incidence graphs. -Roundoff/material nesting-failure behavior from the main plan remains unchanged. +The exact-fit boundary matches the classical model-F rule: + +- if `RSS_FE` is numerically zero while `RSS_pool - RSS_FE` is materially positive, report the limiting result `F = inf`, `p = 0` with the ordinary numerator/denominator df; +- if both pooled and FE RSS are numerically zero, the ratio is indeterminate and the structured result remains inapplicable; +- a materially negative nested-model RSS difference remains inapplicable rather than being clipped. ## R² constant convention clarification @@ -97,6 +101,8 @@ The common-constant projection used by the **pooling F test** is a separate nest For `RandomEffects`, an explicit nonzero constant column in the supplied level design is detected directly. The quasi-demeaned transformed version of that same column is retained as the restricted intercept design for adjusted R² and classical model F, including on unbalanced panels where the transformed intercept is not a vector of ones. +Constant detection is **scale equivariant**: multiplying an identified nonzero constant column by any nonzero unit-conversion factor must not change whether it is classified as a constant. The tolerance is therefore relative to that column's own magnitude; there is no `max(1, scale)` absolute floor. An exactly zero column is not treated as an intercept. + ## Normative post-review overrides Final PR review exposed additional correctness boundaries that supersede conflicting early-plan wording in Sections 5.1--5.3, 5.5, 6, 7, and 12 of `panel_p1_stage_b_diagnostics_plan.md`. @@ -115,6 +121,18 @@ The authoritative Stage-B identity contract is: This bounded hashing transfer is an explicit exception to the early-plan statement that Hausman may transfer only O(k) fingerprint scalars. The statistical estimation, covariance construction, and fit-statistic reductions remain backend-native; the exception exists only to make the identity check collision-resistant. +The full-content digest is constructed only when the fitted FE model is actually in the Stage-B Hausman domain: one-way entity FE with nonrobust covariance. Robust/clustered, time-only, and two-way FE are rejected before identity comparison and must not pay the full X/y host-hash cost. `RandomEffects` remains a potential Hausman input and therefore retains the identity contract. + +### Scale-equivariant numerical tolerances + +RSS, covariance matrices, and coefficient differences carry units. Numerical applicability/rank decisions must therefore be invariant to a change of units. In particular: + +- model-F and pooling-F RSS tolerances scale with the compared RSS values and do not use an absolute `max(1, RSS)` floor; +- Hausman eigenvalue/range tolerances scale with the covariance/difference norms and do not impose a unit-sized absolute floor; +- multiplying `y` and fitted coefficients by `c`, or multiplying a Hausman coefficient difference by `c` and its covariance difference by `c^2`, must leave the dimensionless test statistic/applicability unchanged up to floating-point roundoff. + +The ordinary dimensionless post-computation guard on a near-zero negative test statistic may retain a unit floor because the statistic itself is dimensionless. + ### Classical model-F exact-fit boundary The early generic “unavailable when unrestricted RSS is zero” wording is too coarse. The final Stage-B contract is: @@ -127,11 +145,17 @@ The early generic “unavailable when unrestricted RSS is zero” wording is too `RandomEffects` must detect an actual nonzero constant column in the supplied level design. Because Swamy-Arora quasi-demeaning transforms that column and an unbalanced panel generally does not leave a vector of ones, the transformed constant column itself is the restricted design for adjusted R²/model-F accounting. No implicit intercept is invented when the level design has none. +Physical CUDA validation must include balanced and unbalanced explicit-constant RandomEffects cases, in addition to the ordinary no-explicit-constant cases, and must compare the constant/restricted-design metadata as well as numerical fit statistics. + ## Review status - **[HIGH][INFER] fixed in specification** — Stage-B poolability/model-F inference no longer reuses a legacy FE residual df that differs from the standard nuisance-effect rank convention. - **[HIGH][INFER] fixed after review** — two-way FE nuisance rank uses the observed incidence-graph component count (`N + T - C`) instead of assuming every incomplete panel is connected. - **[HIGH][API/INFER] fixed after review** — Hausman identity uses a collision-resistant full-content digest; low-order moments alone are no longer accepted as proof of sample identity. +- **[CRITICAL][INFER] fixed after fresh review** — F/Hausman applicability tolerances and explicit-constant detection are scale equivariant instead of imposing a unit-sized absolute floor. +- **[HIGH][INFER] fixed after fresh review** — an exact FE fit with positive pooled RSS reports the limiting pooling `F=inf, p=0`; the both-zero case remains explicitly inapplicable. +- **[HIGH][TEST/BACKEND] fixed locally after fresh review** — the physical runner includes balanced/unbalanced explicit-constant RandomEffects cases and checks the restricted-design contract; exact-head P100 execution is still required after the final code head is fixed. +- **[MEDIUM][PERF] fixed/measurement pending** — FE fits outside the Hausman domain no longer build the full-content digest; a dedicated physical benchmark measures the remaining digest overhead for Hausman-compatible one-way FE/RE fits. - **[MEDIUM][INFER] fixed in specification** — FE adjusted R² uses nuisance-rank-consistent total df rather than provisional `n-1`. - **[MEDIUM][INFER] fixed in specification** — overall/between R² centering is explicitly separated from the pooling-F common-constant correction. - **[MEDIUM][INFER] fixed after review** — RandomEffects explicit-constant diagnostics retain the transformed intercept in the restricted fit-space definition. From 360bcaef4dfe54d261c1185e7f55a061a52bd0f1 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 20:38:51 +0800 Subject: [PATCH 075/165] test: lock Stage B physical runner coverage --- ..._panel_stage_b_physical_runner_contract.py | 50 +++++++++++++++++++ 1 file changed, 50 insertions(+) create mode 100644 dev/tests/test_panel_stage_b_physical_runner_contract.py diff --git a/dev/tests/test_panel_stage_b_physical_runner_contract.py b/dev/tests/test_panel_stage_b_physical_runner_contract.py new file mode 100644 index 000000000..6fe5597bf --- /dev/null +++ b/dev/tests/test_panel_stage_b_physical_runner_contract.py @@ -0,0 +1,50 @@ +"""Hosted smoke checks for the PR122 physical GPU acceptance runner.""" + +from __future__ import annotations + +from dev.benchmarks.validate_panel_stage_b_gpu import ( + _dataset, + _fit_cases, + _model_snapshot, +) + + +def test_physical_runner_covers_explicit_constant_re_balanced_and_unbalanced(): + expected_counts = {"balanced": 9, "unbalanced": 8} + + for name, unbalanced in (("balanced", False), ("unbalanced", True)): + X, y, entity, time = _dataset(20260808 + int(unbalanced), unbalanced=unbalanced) + models, diagnostics = _fit_cases( + X, + y, + entity, + time, + "numpy", + unbalanced=unbalanced, + ) + + assert len(models) == expected_counts[name] + assert set(diagnostics) == {f"hausman_{name}"} + + case = f"random_effects_explicit_constant_{name}" + assert case in models + contract = _model_snapshot(models[case])["random_effects_diagnostic_contract"] + assert contract == { + "has_explicit_constant": True, + "constant_column_index": 0, + "restricted_rank": 1, + "model_f_rank_restricted": 1, + "model_f_restricted_design_supplied": True, + } + + +def test_physical_runner_total_model_case_contract_is_seventeen(): + balanced = _dataset(20260808, unbalanced=False) + unbalanced = _dataset(20260809, unbalanced=True) + balanced_models, _ = _fit_cases(*balanced, "numpy", unbalanced=False) + unbalanced_models, _ = _fit_cases(*unbalanced, "numpy", unbalanced=True) + + case_ids = set(balanced_models) | set(unbalanced_models) + assert len(case_ids) == 17 + assert "random_effects_explicit_constant_balanced" in case_ids + assert "random_effects_explicit_constant_unbalanced" in case_ids From 285a9f627b59bca59957ed46eeab2e72eccab00b Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 20:49:02 +0800 Subject: [PATCH 076/165] fix: canonicalize Hausman identity to common slopes --- statgpu/panel/_diagnostics.py | 120 ++++++++++++++++++++++++++++------ 1 file changed, 101 insertions(+), 19 deletions(-) diff --git a/statgpu/panel/_diagnostics.py b/statgpu/panel/_diagnostics.py index 1a6683418..f7b8191e8 100644 --- a/statgpu/panel/_diagnostics.py +++ b/statgpu/panel/_diagnostics.py @@ -4,8 +4,9 @@ fit statistics without changing the Stage-A estimator transformations or covariance definitions. Observation-scale statistical accumulation stays on the selected NumPy/CuPy/Torch backend. Hausman sample identity additionally uses a -chunked full-content SHA-256 over normalized float64 X/y values so different -aligned samples cannot be accepted merely because low-order moments collide. +chunked full-content SHA-256 over normalized float64 y/common-slope values so +different aligned samples cannot be accepted merely because low-order moments +collide, while an RE-only explicit intercept may be absorbed by FE. """ from __future__ import annotations @@ -80,10 +81,9 @@ def _relative_tolerance(*values: float, factor: float = 256.0) -> float: """Return a float64 roundoff tolerance that preserves scale equivariance. Statistical quantities such as RSS and covariance matrices have physical - scale. Using an absolute ``max(1, scale)`` floor makes F/Hausman decisions - depend on the arbitrary units of y or beta. A zero scale therefore maps to - an exact zero tolerance; otherwise the tolerance scales linearly with the - compared quantity. + scale. Using an absolute ``max(1, scale)`` floor makes F/Hausman decisions + depend on arbitrary units. A zero scale therefore maps to an exact zero + tolerance; otherwise the tolerance scales linearly with the compared value. """ scale = max((abs(float(value)) for value in values), default=0.0) return float(factor) * np.finfo(np.float64).eps * scale @@ -579,9 +579,9 @@ def _row_weights(n: int, xp, ref_arr): def _full_content_digest(X, y) -> str: - """Hash every aligned X/y value with bounded chunked host transfers.""" + """Hash every aligned canonical slope-X/y value with bounded host transfers.""" h = hashlib.sha256() - h.update(b"statgpu-panel-diagnostic-identity-v2") + h.update(b"statgpu-panel-diagnostic-identity-v3") for label, array, shape in ( (b"X", X, (int(X.shape[0]), int(X.shape[1]))), @@ -599,9 +599,6 @@ def _full_content_digest(X, y) -> str: copy=True, order="C", ) - # Numerical identity treats signed zero as the same value. Panel - # input validation excludes missing values, so no NaN payload - # canonicalization is required here. chunk[chunk == 0.0] = 0.0 chunk = np.ascontiguousarray(chunk.astype(" Optional[str]: return hashlib.sha256(arr.tobytes()).hexdigest() +def _identity_constant_index(X, *, xp, has_constant: bool) -> Optional[int]: + """Locate the constant column for canonical Hausman slope identity.""" + if not has_constant or int(X.shape[1]) == 0: + return None + if getattr(xp, "__name__", "") == "torch": + col_min_native = xp.amin(X, dim=0) + col_max_native = xp.amax(X, dim=0) + else: + col_min_native = xp.min(X, axis=0) + col_max_native = xp.max(X, axis=0) + col_min = np.asarray(_to_numpy(col_min_native), dtype=np.float64).ravel() + col_max = np.asarray(_to_numpy(col_max_native), dtype=np.float64).ravel() + magnitude = np.maximum(np.abs(col_min), np.abs(col_max)) + span = np.abs(col_max - col_min) + tol = 256.0 * np.finfo(np.float64).eps * magnitude + candidates = np.flatnonzero((span <= tol) & (magnitude > 0.0)) + return None if candidates.size == 0 else int(candidates[0]) + + def _diagnostic_identity( X, y, @@ -649,23 +665,68 @@ def _diagnostic_identity( entity_codes=None, feature_names: Optional[Sequence[str]] = None, has_constant: bool = False, + constant_column_index: Optional[int] = None, ) -> Dict[str, Any]: - k = int(X.shape[1]) - names = tuple(feature_names) if feature_names is not None else tuple( - f"x{i + 1}" for i in range(k) + """Build canonical sample/design identity for a Hausman slope comparison. + + FE absorbs a common intercept, while RE may estimate the same intercept as an + explicit design column. Identity therefore hashes y and only the slope + design. ``coefficient_indices`` maps canonical slope positions back to each + fitted model's original coefficient/covariance positions. + """ + k_raw = int(X.shape[1]) + constant_index = constant_column_index + if constant_index is None: + constant_index = _identity_constant_index( + X, xp=xp, has_constant=bool(has_constant) + ) + if constant_index is not None and not (0 <= int(constant_index) < k_raw): + raise ValueError("constant_column_index is out of range") + + coefficient_indices = tuple( + index for index in range(k_raw) if index != constant_index ) + if len(coefficient_indices) == k_raw: + X_slopes = X + else: + index_dev = xp_asarray( + np.asarray(coefficient_indices, dtype=np.int64), + dtype=xp.int64, + xp=xp, + ref_arr=X, + ) + X_slopes = X[:, index_dev] + + if feature_names is None: + names = tuple(f"x{i + 1}" for i in range(len(coefficient_indices))) + else: + raw_names = tuple(feature_names) + if len(raw_names) == k_raw: + names = tuple(raw_names[index] for index in coefficient_indices) + elif len(raw_names) == len(coefficient_indices): + names = raw_names + else: + raise ValueError( + "feature_names must match the raw or canonical slope feature count" + ) + return { "nobs": int(X.shape[0]), - "n_features": k, + "n_features": int(len(coefficient_indices)), "feature_names": names, + "coefficient_indices": coefficient_indices, "has_constant": bool(has_constant), + "constant_column_index": constant_index, "entity_signature": _metadata_signature(entity_codes), - "fingerprint": _numerical_fingerprint(X, y, xp=xp), + "fingerprint": _numerical_fingerprint(X_slopes, y, xp=xp), } def _fingerprints_match(left: Dict[str, Any], right: Dict[str, Any]) -> Tuple[bool, str]: - scalar_keys = ("nobs", "n_features", "feature_names", "has_constant", "entity_signature") + # ``has_constant`` deliberately is not compared: FE may absorb the common + # intercept while RE estimates it explicitly. Canonical slope X/y identity + # plus entity and feature metadata is authoritative. + scalar_keys = ("nobs", "n_features", "feature_names", "entity_signature") for key in scalar_keys: if left.get(key) != right.get(key): return False, f"diagnostic identity mismatch: {key}" @@ -793,8 +854,24 @@ def hausman_test(fe_model, re_model) -> PanelTestResult: distribution="chi2", reason="Hausman test has no common estimable slope coefficients", ) - fe_lookup = {name: i for i, name in enumerate(fe_names)} - re_lookup = {name: i for i, name in enumerate(re_names)} + + fe_positions = tuple( + int(value) + for value in left_id.get("coefficient_indices", range(len(fe_names))) + ) + re_positions = tuple( + int(value) + for value in right_id.get("coefficient_indices", range(len(re_names))) + ) + if len(fe_positions) != len(fe_names) or len(re_positions) != len(re_names): + return _inapplicable( + null=null, + alternative=alternative, + distribution="chi2", + reason="diagnostic identity has inconsistent coefficient-index metadata", + ) + fe_lookup = dict(zip(fe_names, fe_positions)) + re_lookup = dict(zip(re_names, re_positions)) fe_idx = np.asarray([fe_lookup[name] for name in common], dtype=np.int64) re_idx = np.asarray([re_lookup[name] for name in common], dtype=np.int64) fe_coef = np.asarray(fe_model.coef_, dtype=np.float64).ravel()[fe_idx] @@ -804,6 +881,11 @@ def hausman_test(fe_model, re_model) -> PanelTestResult: result = _hausman_quadratic(fe_coef - re_coef, fe_cov - re_cov) meta = dict(result.metadata) meta["common_features"] = tuple(common) + meta["fe_coefficient_indices"] = tuple(int(value) for value in fe_idx) + meta["re_coefficient_indices"] = tuple(int(value) for value in re_idx) + meta["re_explicit_constant_excluded"] = bool( + right_id.get("constant_column_index") is not None + ) return PanelTestResult( statistic=result.statistic, pvalue=result.pvalue, From 37804bbc8f19d9481cb56f0765c2920ba18c139b Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 20:49:53 +0800 Subject: [PATCH 077/165] test: cover absorbed-intercept Hausman identity --- .../test_panel_stage_b_review_regressions.py | 78 +++++++++++++++++++ 1 file changed, 78 insertions(+) diff --git a/dev/tests/test_panel_stage_b_review_regressions.py b/dev/tests/test_panel_stage_b_review_regressions.py index c3b0c9453..46bdf3eaf 100644 --- a/dev/tests/test_panel_stage_b_review_regressions.py +++ b/dev/tests/test_panel_stage_b_review_regressions.py @@ -73,6 +73,84 @@ def test_hausman_identity_rejects_low_order_moment_collision(): ) +def test_hausman_identity_allows_re_only_explicit_constant(): + rng = np.random.default_rng(20260811) + entity = np.repeat(np.arange(4), 5) + X_slopes = rng.normal(size=(entity.size, 2)) + y = X_slopes @ np.asarray([0.7, -0.25]) + rng.normal(scale=0.1, size=entity.size) + X_re = np.column_stack([np.ones(entity.size), X_slopes]) + + fe_identity = _diagnostic_identity( + X_slopes, + y, + xp=np, + entity_codes=entity, + has_constant=False, + ) + re_identity = _diagnostic_identity( + X_re, + y, + xp=np, + entity_codes=entity, + has_constant=True, + ) + matched, reason = _fingerprints_match(fe_identity, re_identity) + + assert matched, reason + assert fe_identity["feature_names"] == ("x1", "x2") + assert re_identity["feature_names"] == ("x1", "x2") + assert fe_identity["coefficient_indices"] == (0, 1) + assert re_identity["coefficient_indices"] == (1, 2) + assert re_identity["constant_column_index"] == 0 + assert ( + fe_identity["fingerprint"]["content_digest"] + == re_identity["fingerprint"]["content_digest"] + ) + + X_re_changed = X_re.copy() + X_re_changed[0, 2] += 0.5 + changed_identity = _diagnostic_identity( + X_re_changed, + y, + xp=np, + entity_codes=entity, + has_constant=True, + ) + changed_match, changed_reason = _fingerprints_match( + fe_identity, changed_identity + ) + assert not changed_match + assert "content_digest" in changed_reason + + +def test_hausman_end_to_end_excludes_re_only_explicit_constant(): + rng = np.random.default_rng(20260812) + counts = np.asarray([5, 4, 5, 4, 5, 4]) + entity = np.repeat(np.arange(counts.size), counts) + X_slopes = rng.normal(size=(entity.size, 2)) + alpha = np.repeat(np.linspace(-0.35, 0.45, counts.size), counts) + y = 1.25 + X_slopes @ np.asarray([0.65, -0.3]) + alpha + rng.normal( + scale=0.16, size=entity.size + ) + + fe = PanelOLS(entity_effects=True, cov_type="nonrobust").fit( + X_slopes, y, entity_ids=entity + ) + re = RandomEffects().fit( + np.column_stack([np.ones(entity.size), X_slopes]), + y, + entity_ids=entity, + ) + result = fe.hausman_test(re) + + assert "identity mismatch" not in (result.reason or "") + assert "no common estimable slope" not in (result.reason or "") + assert result.metadata["common_features"] == ("x1", "x2") + assert result.metadata["fe_coefficient_indices"] == (0, 1) + assert result.metadata["re_coefficient_indices"] == (1, 2) + assert result.metadata["re_explicit_constant_excluded"] is True + + def test_classical_model_f_reports_infinite_statistic_for_exact_fit(): x = np.linspace(-1.0, 1.0, 8) X = np.column_stack([np.ones(x.size), x]) From 7cf077462a38719bb4e6138eab4ebf3335bbce70 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 20:50:36 +0800 Subject: [PATCH 078/165] test: cover absorbed-intercept Hausman on Torch CPU --- dev/tests/test_panel_stage_b_torch_cpu.py | 40 ++++++++++++++++++++--- 1 file changed, 35 insertions(+), 5 deletions(-) diff --git a/dev/tests/test_panel_stage_b_torch_cpu.py b/dev/tests/test_panel_stage_b_torch_cpu.py index 0a290efaf..942ee9293 100644 --- a/dev/tests/test_panel_stage_b_torch_cpu.py +++ b/dev/tests/test_panel_stage_b_torch_cpu.py @@ -8,6 +8,7 @@ from statgpu.panel import FamaMacBeth, PanelOLS, PooledOLS, RandomEffects from statgpu.panel._diagnostic_context import explicit_constant_column +from statgpu.panel._diagnostics import _diagnostic_identity, _fingerprints_match torch = pytest.importorskip("torch") @@ -84,7 +85,6 @@ def test_stage_b_pooled_torch_cpu_matches_numpy(): assert_allclose(bp_actual.statistic, bp_expected.statistic, rtol=5e-9, atol=5e-10) assert_allclose(bp_actual.pvalue, bp_expected.pvalue, rtol=1e-8, atol=1e-14) - # Exercise the metadata-permutation contract on Torch CPU as well. scrambled = torch.as_tensor((3 - time + 2 * entity) % 5, dtype=torch.int64) hac = PooledOLS(cov_type="hac", bandwidth=1).fit( X_t, @@ -114,7 +114,6 @@ def test_stage_b_panel_fe_torch_cpu_pooling_and_fit_stats_match_numpy(): assert_allclose(pool_actual.statistic, pool_expected.statistic, rtol=5e-9, atol=5e-10) assert_allclose(pool_actual.pvalue, pool_expected.pvalue, rtol=1e-8, atol=1e-14) assert pool_actual.df == pool_expected.df - # Existing Stage-A df remains the compatibility value on both backends. assert actual.df_resid == expected.df_resid assert actual.fit_statistics_.metadata["diagnostic_df"] == expected.fit_statistics_.metadata["diagnostic_df"] @@ -138,9 +137,6 @@ def test_stage_b_random_effects_torch_cpu_fit_stats_and_identity_match_numpy(): assert_allclose(h_actual.pvalue, h_expected.pvalue, rtol=1e-7, atol=1e-12) assert h_actual.df == h_expected.df else: - # A finite-sample covariance difference may be indefinite. The important - # parity contract is that this is reported structurally on both backends, - # not converted into a solve error or a silent fallback. assert h_actual.reason == h_expected.reason @@ -170,6 +166,40 @@ def test_stage_b_random_effects_explicit_constant_torch_cpu_matches_numpy(): ) +def test_stage_b_absorbed_intercept_identity_matches_on_torch_cpu(): + rng = np.random.default_rng(1225) + entity = np.repeat(np.arange(5), 4) + slopes = rng.normal(size=(entity.size, 2)) + y = slopes @ np.asarray([0.55, -0.2]) + rng.normal(scale=0.1, size=entity.size) + slopes_t = torch.as_tensor(slopes, dtype=torch.float64) + y_t = torch.as_tensor(y, dtype=torch.float64) + entity_t = torch.as_tensor(entity, dtype=torch.int64) + re_t = torch.cat( + [torch.ones((entity.size, 1), dtype=torch.float64), slopes_t], dim=1 + ) + + fe_identity = _diagnostic_identity( + slopes_t, + y_t, + xp=torch, + entity_codes=entity_t, + has_constant=False, + ) + re_identity = _diagnostic_identity( + re_t, + y_t, + xp=torch, + entity_codes=entity_t, + has_constant=True, + ) + matched, reason = _fingerprints_match(fe_identity, re_identity) + + assert matched, reason + assert fe_identity["coefficient_indices"] == (0, 1) + assert re_identity["coefficient_indices"] == (1, 2) + assert fe_identity["feature_names"] == re_identity["feature_names"] == ("x1", "x2") + + def test_stage_b_torch_constant_detection_is_scale_invariant(): slope = torch.linspace(-1.0, 1.0, 9, dtype=torch.float64) for scale in (1.0, 1e-8, 1e-12): From 658964f666f85fc3fcb932affd0362bdde01e930 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 20:52:02 +0800 Subject: [PATCH 079/165] test: validate absorbed-intercept Hausman on physical GPU --- dev/benchmarks/validate_panel_stage_b_gpu.py | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/dev/benchmarks/validate_panel_stage_b_gpu.py b/dev/benchmarks/validate_panel_stage_b_gpu.py index 32d9338ed..1bd9f71d5 100644 --- a/dev/benchmarks/validate_panel_stage_b_gpu.py +++ b/dev/benchmarks/validate_panel_stage_b_gpu.py @@ -213,10 +213,11 @@ def _fit_cases(X, y, entity, time, backend, *, unbalanced): re = RandomEffects(device=device).fit(Xb, yb, entity_ids=eb) cases[f"random_effects_{suffix}"] = re - # Exercise the explicit-constant RandomEffects branch on the physical GPU. - # This is intentionally a separate case so the no-intercept Stage-A path - # remains independently frozen by the ordinary RandomEffects case above. - X_constant = np.column_stack([np.ones(X.shape[0]), X[:, 0]]) + # Exercise the explicit-constant RandomEffects branch on the physical GPU + # using the same two slopes as FE. This validates both transformed-intercept + # diagnostics and the standard Hausman parameterization where FE absorbs the + # common intercept while RE estimates it explicitly. + X_constant = np.column_stack([np.ones(X.shape[0]), X]) Xcb, ycb, ecb, _ = _to_backend_arrays( X_constant, y, entity, time, backend ) @@ -233,6 +234,9 @@ def _fit_cases(X, y, entity, time, backend, *, unbalanced): diagnostics = { f"hausman_{suffix}": _test_result(fe.hausman_test(re)), + f"hausman_explicit_re_constant_{suffix}": _test_result( + fe.hausman_test(re_constant) + ), } if not unbalanced: From 3f38fe2ec8194aa3ba64002580cdd18e3de0d311 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 20:52:31 +0800 Subject: [PATCH 080/165] test: lock absorbed-intercept physical diagnostics --- ..._panel_stage_b_physical_runner_contract.py | 21 ++++++++++++++++--- 1 file changed, 18 insertions(+), 3 deletions(-) diff --git a/dev/tests/test_panel_stage_b_physical_runner_contract.py b/dev/tests/test_panel_stage_b_physical_runner_contract.py index 6fe5597bf..8ae87c7e0 100644 --- a/dev/tests/test_panel_stage_b_physical_runner_contract.py +++ b/dev/tests/test_panel_stage_b_physical_runner_contract.py @@ -24,7 +24,10 @@ def test_physical_runner_covers_explicit_constant_re_balanced_and_unbalanced(): ) assert len(models) == expected_counts[name] - assert set(diagnostics) == {f"hausman_{name}"} + assert set(diagnostics) == { + f"hausman_{name}", + f"hausman_explicit_re_constant_{name}", + } case = f"random_effects_explicit_constant_{name}" assert case in models @@ -37,14 +40,26 @@ def test_physical_runner_covers_explicit_constant_re_balanced_and_unbalanced(): "model_f_restricted_design_supplied": True, } + absorbed = diagnostics[f"hausman_explicit_re_constant_{name}"] + assert "identity mismatch" not in (absorbed["reason"] or "") + assert "no common estimable slope" not in (absorbed["reason"] or "") + def test_physical_runner_total_model_case_contract_is_seventeen(): balanced = _dataset(20260808, unbalanced=False) unbalanced = _dataset(20260809, unbalanced=True) - balanced_models, _ = _fit_cases(*balanced, "numpy", unbalanced=False) - unbalanced_models, _ = _fit_cases(*unbalanced, "numpy", unbalanced=True) + balanced_models, balanced_diagnostics = _fit_cases( + *balanced, "numpy", unbalanced=False + ) + unbalanced_models, unbalanced_diagnostics = _fit_cases( + *unbalanced, "numpy", unbalanced=True + ) case_ids = set(balanced_models) | set(unbalanced_models) + diagnostic_ids = set(balanced_diagnostics) | set(unbalanced_diagnostics) assert len(case_ids) == 17 + assert len(diagnostic_ids) == 4 assert "random_effects_explicit_constant_balanced" in case_ids assert "random_effects_explicit_constant_unbalanced" in case_ids + assert "hausman_explicit_re_constant_balanced" in diagnostic_ids + assert "hausman_explicit_re_constant_unbalanced" in diagnostic_ids From 85dc6cff1d433603b20243740e18675bae4828f1 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 20:54:04 +0800 Subject: [PATCH 081/165] test: align absorbed-intercept Hausman structure with linearmodels --- dev/tests/test_panel_stage_b_linearmodels.py | 46 ++++++++++++++------ 1 file changed, 33 insertions(+), 13 deletions(-) diff --git a/dev/tests/test_panel_stage_b_linearmodels.py b/dev/tests/test_panel_stage_b_linearmodels.py index 4d47da0be..9c11e582d 100644 --- a/dev/tests/test_panel_stage_b_linearmodels.py +++ b/dev/tests/test_panel_stage_b_linearmodels.py @@ -49,12 +49,6 @@ def _panel(seed=1260, *, unbalanced=False): scale=0.2, size=entity.size ) if unbalanced: - # Deliberately contains internal gaps. This is appropriate for pooled, - # between and FE comparisons, but it is not used for FirstDifference - # because Stage A preserves statgpu's adjacent-observed-row differencing - # contract while linearmodels constructs first differences on its panel - # time grid. Stage B must not use an external gate to change that - # estimator transformation implicitly. keep = np.ones(entity.size, dtype=bool) keep[[1, 8, 17, 31, 44]] = False X, y, entity, time = X[keep], y[keep], entity[keep], time[keep] @@ -65,8 +59,6 @@ def _gap_free_unbalanced_panel(seed=1263): """Return an unbalanced panel with contiguous time support per entity.""" X, y, entity, time = _panel(seed=seed, unbalanced=False) keep = np.ones(len(y), dtype=bool) - # Remove only trailing observations from selected entities, so every - # retained entity still has contiguous time indices starting at zero. keep[(entity == 1) & (time >= 5)] = False keep[(entity == 3) & (time >= 4)] = False keep[(entity == 7) & (time >= 3)] = False @@ -142,10 +134,6 @@ def test_one_way_panelols_matches_linearmodels_parameter_r2_f_pooling_and_diagno assert_allclose(pooled.statistic, lm.f_pooled.stat, rtol=2e-9, atol=2e-11) assert_allclose(pooled.pvalue, lm.f_pooled.pval, rtol=2e-8, atol=1e-14) assert pooled.df == (float(lm.f_pooled.df), float(lm.f_pooled.df_denom)) - - # Stage-A public FE bse intentionally preserves its historical df. Stage-B - # Hausman uses a separate small covariance rescaled to the standard full - # nuisance-effect rank; this matrix should align with linearmodels. assert_allclose( sg._panel_cov_params, lm.cov.to_numpy(), @@ -222,6 +210,38 @@ def test_random_effects_explicit_constant_matches_linearmodels_f_df_structure(): ) +def test_hausman_absorbed_intercept_matches_linearmodels_parameter_structure(): + X, y, entity, time = _panel(seed=1265, unbalanced=True) + y_lm, X_lm = _lm_data(X, y, entity, time, constant=False) + _, X_lm_const = _lm_data(X, y, entity, time, constant=True) + + lm_fe = LMPanelOLS(y_lm, X_lm, entity_effects=True).fit( + cov_type="unadjusted", debiased=True + ) + lm_re = LMRandomEffects(y_lm, X_lm_const).fit( + cov_type="unadjusted", debiased=True + ) + assert tuple(lm_fe.params.index) == ("x1", "x2") + assert tuple(lm_re.params.index) == ("const", "x1", "x2") + + sg_fe = PanelOLS(entity_effects=True, cov_type="nonrobust").fit( + X, y, entity_ids=entity + ) + sg_re = RandomEffects().fit( + np.column_stack([np.ones(X.shape[0]), X]), + y, + entity_ids=entity, + ) + result = sg_fe.hausman_test(sg_re) + + assert "identity mismatch" not in (result.reason or "") + assert "no common estimable slope" not in (result.reason or "") + assert result.metadata["common_features"] == ("x1", "x2") + assert result.metadata["fe_coefficient_indices"] == (0, 1) + assert result.metadata["re_coefficient_indices"] == (1, 2) + assert result.metadata["re_explicit_constant_excluded"] is True + + def test_first_difference_matches_linearmodels_when_transformed_sample_is_common(): X, y, entity, time = _gap_free_unbalanced_panel() y_lm, X_lm = _lm_data(X, y, entity, time, constant=False) @@ -233,4 +253,4 @@ def test_first_difference_matches_linearmodels_when_transformed_sample_is_common ) assert_allclose(sg_fd.coef_, lm_fd.params.to_numpy(), rtol=2e-10, atol=2e-11) _assert_r2(sg_fd.fit_statistics_, lm_fd) - _assert_model_f(sg_fd.fit_statistics_, lm_fd) \ No newline at end of file + _assert_model_f(sg_fd.fit_statistics_, lm_fd) From 1cdef7794372331ecfaa129ca123c6fdbf35643f Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 20:55:27 +0800 Subject: [PATCH 082/165] docs: define canonical-slope Hausman identity --- ...anel_p1_stage_b_diagnostics_df_addendum.md | 22 ++++++++++++++----- 1 file changed, 16 insertions(+), 6 deletions(-) diff --git a/dev/plans/panel_p1_stage_b_diagnostics_df_addendum.md b/dev/plans/panel_p1_stage_b_diagnostics_df_addendum.md index 666690051..63e2cf1c6 100644 --- a/dev/plans/panel_p1_stage_b_diagnostics_df_addendum.md +++ b/dev/plans/panel_p1_stage_b_diagnostics_df_addendum.md @@ -111,18 +111,25 @@ Final PR review exposed additional correctness boundaries that supersede conflic The earlier O(k) low-order-moment fingerprint is retained only as optional audit metadata; it is **not** sufficient proof that FE and RE used the same aligned numerical sample. Distinct row sequences can share sums, sums of squares, and index-weighted first moments. +A standard FE-vs-RE Hausman comparison may absorb the common intercept in the FE nuisance-effect space while estimating an explicit intercept in RE. Consequently identity is defined on the **canonical common-slope design**, not on raw full design matrices that differ only by an RE intercept. + The authoritative Stage-B identity contract is: -- compute a versioned SHA-256 digest over **every aligned float64 X/y value in row order**, including shape framing; -- compare the digest together with feature-name/intercept metadata and a separate aligned entity-code signature; +- remove the identified explicit constant column, if any, before constructing the Hausman design identity; +- compute a versioned SHA-256 digest over every aligned float64 **slope-X/y** value in row order, including shape framing; +- compare exact canonical slope feature names, the canonical slope count, the digest, and the aligned entity-code signature; +- do **not** require FE and RE `has_constant` metadata to agree when their canonical slope design is identical; +- retain a `coefficient_indices` map from canonical slope positions back to each fitted model's original coefficient/covariance positions, so an RE intercept at position 0 produces slope indices `(1, 2, ...)` rather than silently shifting the comparison; - require exact digest equality rather than an `allclose` tolerance for identity; -- on CuPy/Torch fits, transfer X/y to host in bounded chunks solely for hashing; no single extra full-design host allocation is required; -- persist only the digest and compact metadata after hashing, never a second retained CPU copy of the full design. +- on CuPy/Torch fits, transfer the canonical slope X/y to host in bounded chunks solely for hashing; no single extra full-design host allocation is required; +- persist only the digest, coefficient-index map, and compact metadata after hashing, never a second retained CPU copy of the design. This bounded hashing transfer is an explicit exception to the early-plan statement that Hausman may transfer only O(k) fingerprint scalars. The statistical estimation, covariance construction, and fit-statistic reductions remain backend-native; the exception exists only to make the identity check collision-resistant. The full-content digest is constructed only when the fitted FE model is actually in the Stage-B Hausman domain: one-way entity FE with nonrobust covariance. Robust/clustered, time-only, and two-way FE are rejected before identity comparison and must not pay the full X/y host-hash cost. `RandomEffects` remains a potential Hausman input and therefore retains the identity contract. +For array input without explicit feature names, canonical slopes are renumbered after removal of an RE-only constant (`x1`, `x2`, ...), while the stored coefficient-index map preserves the original RE positions. For named/formula designs, the canonical slope names are retained and the intercept is excluded. + ### Scale-equivariant numerical tolerances RSS, covariance matrices, and coefficient differences carry units. Numerical applicability/rank decisions must therefore be invariant to a change of units. In particular: @@ -145,7 +152,9 @@ The early generic “unavailable when unrestricted RSS is zero” wording is too `RandomEffects` must detect an actual nonzero constant column in the supplied level design. Because Swamy-Arora quasi-demeaning transforms that column and an unbalanced panel generally does not leave a vector of ones, the transformed constant column itself is the restricted design for adjusted R²/model-F accounting. No implicit intercept is invented when the level design has none. -Physical CUDA validation must include balanced and unbalanced explicit-constant RandomEffects cases, in addition to the ordinary no-explicit-constant cases, and must compare the constant/restricted-design metadata as well as numerical fit statistics. +Physical CUDA validation must include balanced and unbalanced explicit-constant RandomEffects cases, in addition to the ordinary no-explicit-constant cases, and must compare the constant/restricted-design metadata as well as numerical fit statistics. The same runner must also evaluate FE-vs-RE Hausman with the RE-only explicit constant on both balanced and unbalanced panels, so the canonical slope digest and coefficient-index mapping are exercised on CuPy and Torch CUDA. + +The final physical runner therefore contains 17 distinct estimator model cases per backend and four Hausman diagnostic cases per backend: ordinary and explicit-RE-constant parameterizations on balanced and unbalanced panels. ## Review status @@ -154,7 +163,8 @@ Physical CUDA validation must include balanced and unbalanced explicit-constant - **[HIGH][API/INFER] fixed after review** — Hausman identity uses a collision-resistant full-content digest; low-order moments alone are no longer accepted as proof of sample identity. - **[CRITICAL][INFER] fixed after fresh review** — F/Hausman applicability tolerances and explicit-constant detection are scale equivariant instead of imposing a unit-sized absolute floor. - **[HIGH][INFER] fixed after fresh review** — an exact FE fit with positive pooled RSS reports the limiting pooling `F=inf, p=0`; the both-zero case remains explicitly inapplicable. -- **[HIGH][TEST/BACKEND] fixed locally after fresh review** — the physical runner includes balanced/unbalanced explicit-constant RandomEffects cases and checks the restricted-design contract; exact-head P100 execution is still required after the final code head is fixed. +- **[HIGH][INFER/API] fixed after thread-aware re-review** — Hausman identity is canonicalized to common slopes, so an FE-absorbed intercept and an RE-only explicit constant no longer cause a false identity rejection or coefficient-index shift. +- **[HIGH][TEST/BACKEND] fixed locally after fresh review** — the physical runner includes balanced/unbalanced explicit-constant RandomEffects cases plus explicit-constant Hausman diagnostics and checks the restricted-design contract; exact-head P100 execution is still required after the final code head is fixed. - **[MEDIUM][PERF] fixed/measurement pending** — FE fits outside the Hausman domain no longer build the full-content digest; a dedicated physical benchmark measures the remaining digest overhead for Hausman-compatible one-way FE/RE fits. - **[MEDIUM][INFER] fixed in specification** — FE adjusted R² uses nuisance-rank-consistent total df rather than provisional `n-1`. - **[MEDIUM][INFER] fixed in specification** — overall/between R² centering is explicitly separated from the pooling-F common-constant correction. From 8a7ff31c630d3be9d3518d3974b458efe00fe469 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 20:57:28 +0800 Subject: [PATCH 083/165] docs: document final Stage B numerical boundaries --- docs/en/models/panel.md | 25 +++++++++++++++---------- 1 file changed, 15 insertions(+), 10 deletions(-) diff --git a/docs/en/models/panel.md b/docs/en/models/panel.md index 2a399f31d..267e5ae52 100644 --- a/docs/en/models/panel.md +++ b/docs/en/models/panel.md @@ -128,7 +128,7 @@ For coefficient vector \(\hat\beta\): - **between R²** evaluates entity means \(\bar y_i-\bar X_i\hat\beta\); - **within R²** evaluates entity-demeaned \(y\) and \(X\). -Overall and between total sums of squares are centered only when the actual level regressor design contains an identified constant. Fixed effects by themselves do not change this centering rule. `RandomEffects` detects an explicit nonzero constant column in the supplied level design and retains its quasi-demeaned transformed column when defining adjusted R² and the restricted model-F regression. A zero total sum of squares is reported as `0.0` in the standardized Stage-B field and marked in `metadata["degenerate_total_ss"]`. +Overall and between total sums of squares are centered only when the actual level regressor design contains an identified constant. Fixed effects by themselves do not change this centering rule. `RandomEffects` detects an explicit nonzero constant column in the supplied level design and retains its quasi-demeaned transformed column when defining adjusted R² and the restricted model-F regression. Constant detection uses a tolerance relative to the column's own magnitude, so changing units does not turn a nonzero constant into a slope or vice versa. A zero total sum of squares is reported as `0.0` in the standardized Stage-B field and marked in `metadata["degenerate_total_ss"]`. ### Legacy `PanelOLS.rsquared_within` @@ -172,7 +172,7 @@ F= {RSS_U/\mathrm{df}_{\mathrm{resid}}}, $$ -where \(q\) is the effective restriction rank. A robust or clustered covariance choice does not silently convert this field into a robust Wald test. When the unrestricted regression fits exactly while the restricted regression has positive RSS, the standardized result is the limiting classical value `F=inf`, `p=0` rather than an unavailable statistic. +where \(q\) is the effective restriction rank. A robust or clustered covariance choice does not silently convert this field into a robust Wald test. When the unrestricted regression fits exactly while the restricted regression has positive RSS, the standardized result is the limiting classical value `F=inf`, `p=0` rather than an unavailable statistic. RSS zero/nesting tolerances are relative to the RSS scale, so multiplying the response and fitted coefficients by a common unit-conversion factor does not change the dimensionless F statistic or its applicability. `FamaMacBeth` does not receive a residual-OLS model F or adjusted R². Its covariance is based on the time series of cross-sectional coefficient estimates, and Stage B does not relabel that beta-series inference as residual OLS. @@ -194,6 +194,8 @@ The classical poolability null is that all included fixed effects are jointly ze When the FE level design has no explicit constant, the pooled null projects both y and X off the common constant before fitting the slopes. This prevents the common mean from being counted as a tested fixed effect. The numerator and denominator degrees of freedom are derived from effective nested-model ranks, not hard-coded effect counts. +If the fixed-effects fit is exact (`RSS_FE` numerically zero) while the restricted pooled RSS is materially positive, the classical limiting result is `F=inf`, `p=0`. If both pooled and FE RSS are numerically zero, the ratio is indeterminate and the structured result is inapplicable. These zero/nesting decisions use RSS-relative tolerances rather than a unit-sized absolute floor. + The test is classical/homoskedastic even when the fitted FE object uses a robust or clustered covariance for coefficient inference. ### Breusch-Pagan LM for entity random effects @@ -236,12 +238,15 @@ Applicability rules are explicit: - FE must be one-way entity effects only; - the FE coefficient covariance must be classical/nonrobust; -- FE and RE must be fitted to the same aligned X/y/entity sample and common slope design; -- row/sample compatibility uses a collision-resistant SHA-256 digest of every aligned float64 X/y value plus the entity-code signature and feature metadata, not only matching shapes or low-order moments; -- intercepts are excluded from the comparison; +- FE and RE must be fitted to the same aligned y/entity sample and the same canonical slope design; +- an RE-only explicit constant is allowed because entity FE absorbs the common intercept; that constant is excluded from the Hausman coefficient vector; +- row/sample compatibility uses a collision-resistant SHA-256 digest of every aligned float64 **slope-X/y** value plus the entity-code signature and canonical feature metadata, not only matching shapes or low-order moments; +- canonical slope positions retain a map to each model's original coefficient/covariance positions, so an RE intercept at position 0 does not shift `x1`, `x2`, ... into the wrong coefficients; - a materially indefinite covariance difference is reported as inapplicable instead of being eigenvalue-clipped into a statistic. -For GPU fits, the full-content digest is computed through bounded chunks copied to host solely for hashing. The fitted model stores only the digest and compact metadata; it does not retain a second CPU copy of the full design. Statistical estimation, covariance construction, and fit-statistic reductions remain on the selected numerical backend. +For array input, slopes are canonically renumbered after an RE-only constant is removed. For named/formula designs, slope names are preserved. Hausman covariance-rank and identified-range tolerances are relative to the covariance/coefficient scale, so a change of outcome units does not change applicability for the same mathematical problem. + +For GPU fits, the canonical slope full-content digest is computed through bounded chunks copied to host solely for hashing. One-way entity FE with nonrobust covariance and `RandomEffects` retain this identity because they can participate in Stage-B Hausman. Robust/clustered, time-only, and two-way FE are rejected before identity comparison and do not pay the full X/y hashing cost. Fitted models retain only the digest/index metadata, not a second CPU copy of the design. Statistical estimation, covariance construction, and fit-statistic reductions remain on the selected numerical backend. If the covariance difference is positive semidefinite but rank-deficient, statgpu provides a documented generalized-inverse extension: the test uses the identified range and chi-square degrees of freedom equal to the numerical rank, but only when the coefficient difference lies in that range. Metadata records `used_pinv=True` and labels this as the `singular PSD generalized-inverse Hausman` extension. Robust auxiliary-regression Hausman is not part of Stage B. @@ -331,7 +336,7 @@ re = RandomEffects(device="cpu").fit(X, y, entity_ids=entity_ids) print(fe.hausman_test(re)) ``` -For CuPy CUDA use `device="cuda"`; for Torch CUDA use CUDA tensors and `device="torch"`. Stage-B statistical transforms and sufficient-statistic accumulation follow the selected numerical backend. Formula/label metadata, final scalars, and small covariance matrices use the CPU metadata boundary; Hausman additionally performs a bounded chunked host copy of aligned X/y solely to compute the full-content identity digest. +For CuPy CUDA use `device="cuda"`; for Torch CUDA use CUDA tensors and `device="torch"`. Stage-B statistical transforms and sufficient-statistic accumulation follow the selected numerical backend. Formula/label metadata, final scalars, and small covariance matrices use the CPU metadata boundary; Hausman-compatible one-way FE/RE fits additionally perform bounded chunked host copies of canonical slope X/y solely for collision-resistant identity hashing. ## Outputs @@ -348,13 +353,13 @@ Common fitted attributes include: ## Formula and Metadata Boundaries -Formula evaluation may drop rows with missing values. Entity, time, cluster, and other side arrays are aligned to the retained rows. String and categorical labels are factorized on CPU; numerical transforms and sufficient-statistic calculations remain on the selected backend. Hausman computes a full-content SHA-256 identity by copying aligned X/y to host in bounded chunks, then stores only the digest, feature/entity metadata, and a small covariance matrix rather than a second CPU copy of the full design. +Formula evaluation may drop rows with missing values. Entity, time, cluster, and other side arrays are aligned to the retained rows. String and categorical labels are factorized on CPU; numerical transforms and sufficient-statistic calculations remain on the selected backend. For Hausman-compatible fits, canonical slope X/y are copied to host in bounded chunks for SHA-256 identity, after excluding any RE-only explicit constant; the fitted model stores only the digest, original coefficient-index map, feature/entity metadata, and a small covariance matrix rather than a second CPU copy of the design. ## Validation Stage A / PR #119 established the shared panel framework and passed exact-head physical validation on Tesla P100 across 10 CuPy and 10 Torch cases. -Stage B adds maintained analytic and fitted-model regression tests, formula/missing-row alignment tests, Python 3.9 + Torch 2.0 CPU parity coverage, and an executable `linearmodels==7.0` external-definition gate. Final promotion also requires `dev/benchmarks/validate_panel_stage_b_gpu.py` to pass on an exact clean commit for both CuPy and Torch CUDA; this runner is a correctness/provenance gate rather than a performance benchmark. +Stage B adds maintained analytic and fitted-model regression tests, formula/missing-row alignment tests, Python 3.9 + Torch 2.0 CPU parity coverage, and an executable `linearmodels==7.0` external-definition gate. The physical runner contains 17 estimator cases per backend and four Hausman diagnostic cases per backend, including balanced/unbalanced RandomEffects with an explicit constant and FE-versus-RE Hausman where FE absorbs that intercept. Final promotion requires `dev/benchmarks/validate_panel_stage_b_gpu.py` to pass on an exact clean commit for both CuPy and Torch CUDA; this runner is a correctness/provenance gate rather than a performance benchmark. A separate physical benchmark measures the remaining full-content identity overhead on Hausman-compatible FE/RE fits. ## References @@ -364,4 +369,4 @@ Stage B adds maintained analytic and fitted-model regression tests, formula/miss - White, H. (1980). A heteroskedasticity-consistent covariance matrix estimator. - Newey, W. K., & West, K. D. (1987). A simple, positive semi-definite, heteroskedasticity and autocorrelation consistent covariance matrix. - Fama, E. F., & MacBeth, J. D. (1973). Risk, return, and equilibrium. -- Cameron, A. C., Gelbach, J. B., & Miller, D. L. (2011). Robust inference with multiway clustering. \ No newline at end of file +- Cameron, A. C., Gelbach, J. B., & Miller, D. L. (2011). Robust inference with multiway clustering. From 9c78bf6687b2689e3d502e4c8fa4b6ccb355c931 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 20:58:41 +0800 Subject: [PATCH 084/165] =?UTF-8?q?docs:=20=E5=90=8C=E6=AD=A5=20Stage=20B?= =?UTF-8?q?=20=E6=9C=80=E7=BB=88=E6=95=B0=E5=80=BC=E8=BE=B9=E7=95=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/cn/models/panel.md | 25 +++++++++++++++---------- 1 file changed, 15 insertions(+), 10 deletions(-) diff --git a/docs/cn/models/panel.md b/docs/cn/models/panel.md index 61c596fc0..774ed2a45 100644 --- a/docs/cn/models/panel.md +++ b/docs/cn/models/panel.md @@ -128,7 +128,7 @@ within/between/overall R² 采用与 `linearmodels` 对齐的 parameter-based - **between R²** 在个体均值上评价 \(\bar y_i-\bar X_i\hat\beta\)； - **within R²** 在 entity-demeaned 的 y 和 X 上评价同一系数向量。 -只有 level regressor design 中存在实际可识别的常数项时，overall 和 between total sum of squares 才中心化。固定效应本身不会自动改变这一规则。`RandomEffects` 会检测传入 level design 中显式的非零常数列，并在 adjusted R² 与 restricted model-F 中保留其 quasi-demeaned transformed column。若 total sum of squares 为 0，Stage-B 标准字段返回 `0.0`，并在 `metadata["degenerate_total_ss"]` 中标记。 +只有 level regressor design 中存在实际可识别的常数项时，overall 和 between total sum of squares 才中心化。固定效应本身不会自动改变这一规则。`RandomEffects` 会检测传入 level design 中显式的非零常数列，并在 adjusted R² 与 restricted model-F 中保留其 quasi-demeaned transformed column。常数检测的容差相对于该列自身量级定义，因此仅改变单位不会把一个非零常数误判成 slope，反之亦然。若 total sum of squares 为 0，Stage-B 标准字段返回 `0.0`，并在 `metadata["degenerate_total_ss"]` 中标记。 ### Legacy `PanelOLS.rsquared_within` @@ -172,7 +172,7 @@ F= {RSS_U/\mathrm{df}_{\mathrm{resid}}}, $$ -其中 \(q\) 是有效 restriction rank。即使 estimator 的 coefficient covariance 使用 robust 或 clustered 选项，这一字段也不会静默变成 robust Wald test。当 unrestricted regression 精确拟合而 restricted regression 的 RSS 为正时，标准化结果采用经典极限值 `F=inf`、`p=0`，而不是把统计量标成 unavailable。 +其中 \(q\) 是有效 restriction rank。即使 estimator 的 coefficient covariance 使用 robust 或 clustered 选项，这一字段也不会静默变成 robust Wald test。当 unrestricted regression 精确拟合而 restricted regression 的 RSS 为正时，标准化结果采用经典极限值 `F=inf`、`p=0`，而不是把统计量标成 unavailable。RSS 的 zero/nesting tolerance 按 RSS 自身量级缩放，因此将 response 与 fitted coefficient 同时乘一个单位变换常数不会改变无量纲 F statistic 或 applicability。 `FamaMacBeth` 不定义 residual-OLS model F 或 adjusted R²，因为其 covariance 来自逐期横截面系数时间序列；Stage B 不会把 beta-series inference 重命名成 residual OLS inference。 @@ -194,6 +194,8 @@ result = pooling_f_test(fe) 当 FE level design 没有显式常数时，pooled null 会先从 y 和 X 中投影掉共同常数，再拟合 slope，避免把共同均值误计入被检验的 fixed effects。分子和分母自由度由有效 nested-model rank 推导，而不是硬编码 effect count。 +如果 fixed-effects fit 精确拟合（`RSS_FE` 在数值上为 0），而 restricted pooled RSS 实质为正，则经典极限结果为 `F=inf`、`p=0`；若 pooled 与 FE RSS 都为 0，则比值不定，返回结构化 inapplicable。以上 zero/nesting 判定使用相对于 RSS 量级的 tolerance，不使用固定的 unit-size floor。 + 即使 FE 对象的系数推断采用 robust 或 clustered covariance，这个 pooling F 仍是 classical/homoskedastic test。 ### 个体随机效应 Breusch-Pagan LM @@ -236,12 +238,15 @@ $$ - FE 必须只有 one-way entity effects； - FE coefficient covariance 必须是 classical/nonrobust； -- FE 与 RE 必须来自同一个对齐后的 X/y/entity 样本和共同 slope design； -- 行/样本一致性使用所有对齐 float64 X/y 值的 collision-resistant SHA-256 digest，并结合 entity-code signature 与 feature metadata，而不是只比较 shape 或低阶 moments； -- intercept 不进入共同 slope 比较； +- FE 与 RE 必须来自同一个对齐后的 y/entity 样本和同一个 canonical slope design； +- RE 可以比 FE 多一个显式常数，因为 entity FE 已吸收共同 intercept；该常数不会进入 Hausman coefficient vector； +- 行/样本一致性使用所有对齐 float64 **slope-X/y** 值的 collision-resistant SHA-256 digest，并结合 entity-code signature 与 canonical feature metadata，而不是只比较 shape 或低阶 moments； +- canonical slope position 会保留到各模型原始 coefficient/covariance position 的映射，因此 RE 的第 0 列 intercept 不会把 `x1`、`x2` 错配到错误系数； - covariance difference 若实质上 indefinite，则返回 inapplicable，不通过 eigenvalue clipping 强行制造统计量。 -GPU 拟合下，full-content digest 仅为了 hashing 而通过有界 chunk 分批复制到 host；拟合对象只保存 digest 与紧凑 metadata，不保留第二份完整 CPU design copy。统计估计、covariance 构造与 fit-statistic reduction 仍在所选数值 backend 上完成。 +数组输入下，在移除 RE-only constant 后 slope 会重新按 `x1`、`x2`、... 做 canonical 编号；named/formula design 则保留 slope 名称。Hausman covariance rank 与 identified-range tolerance 按 covariance/coefficient 自身量级缩放，所以改变 outcome 单位不会改变同一数学问题的 applicability。 + +GPU 拟合下，canonical slope full-content digest 仅为了 hashing 而通过有界 chunk 分批复制到 host。只有可进入 Stage-B Hausman 的 one-way entity nonrobust FE 与 `RandomEffects` 保留该 identity；robust/clustered、time-only、two-way FE 在 identity compare 前就会被判不适用，因此不承担完整 X/y hashing 开销。拟合对象只保存 digest/index metadata，不保留第二份完整 CPU design copy。统计估计、covariance 构造与 fit-statistic reduction 仍在所选数值 backend 上完成。 若 covariance difference 为 positive semidefinite 但 rank deficient，statgpu 提供显式记录的 generalized-inverse extension：只在 coefficient difference 位于 identified range 内时计算，并使用 numerical rank 作为 chi-square df。metadata 会记录 `used_pinv=True` 和 `singular PSD generalized-inverse Hausman`。Stage B 不实现 robust auxiliary-regression Hausman。 @@ -331,7 +336,7 @@ re = RandomEffects(device="cpu").fit(X, y, entity_ids=entity_ids) print(fe.hausman_test(re)) ``` -CuPy CUDA 使用 `device="cuda"`；Torch CUDA 使用 CUDA tensor 并设置 `device="torch"`。Stage-B 的统计变换与 sufficient-statistic accumulation 跟随所选数值 backend；formula/label metadata、最终 scalar 与小型 covariance matrix 使用 CPU metadata boundary；Hausman 还会仅为 full-content identity digest 对对齐 X/y 做有界分块 host copy。 +CuPy CUDA 使用 `device="cuda"`；Torch CUDA 使用 CUDA tensor 并设置 `device="torch"`。Stage-B 的统计变换与 sufficient-statistic accumulation 跟随所选数值 backend；formula/label metadata、最终 scalar 与小型 covariance matrix 使用 CPU metadata boundary；Hausman-compatible one-way FE/RE 拟合还会仅为 collision-resistant identity hashing 对 canonical slope X/y 做有界分块 host copy。 ## 输出 @@ -348,13 +353,13 @@ CuPy CUDA 使用 `device="cuda"`；Torch CUDA 使用 CUDA tensor 并设置 `devi ## Formula 与元数据边界 -formula evaluation 可能因为 missing value 删除行。entity、time、cluster 等 side array 会与保留行同步对齐。字符串和分类标签在 CPU 上 factorize；数值变换与 sufficient-statistic calculation 继续留在所选 backend。Hausman 会把对齐 X/y 以有界 chunk 复制到 host 计算 full-content SHA-256 identity，随后只保存 digest、feature/entity metadata 与小型 covariance matrix，不保存第二份完整 CPU design copy。 +formula evaluation 可能因为 missing value 删除行。entity、time、cluster 等 side array 会与保留行同步对齐。字符串和分类标签在 CPU 上 factorize；数值变换与 sufficient-statistic calculation 继续留在所选 backend。对 Hausman-compatible 拟合，会先排除 RE-only 显式常数，再把 canonical slope X/y 以有界 chunk 复制到 host 计算 SHA-256 identity；随后只保存 digest、原始 coefficient-index 映射、feature/entity metadata 与小型 covariance matrix，不保存第二份完整 CPU design copy。 ## 验证 Stage A / PR #119 建立共享 Panel framework，并在 Tesla P100 上通过 10 个 CuPy + 10 个 Torch exact-head physical cases。 -Stage B 增加 maintained analytic/fitted-model regression tests、formula/missing-row alignment、Python 3.9 + Torch 2.0 CPU parity，以及可执行的 `linearmodels==7.0` external-definition gate。最终 promotion 还要求 `dev/benchmarks/validate_panel_stage_b_gpu.py` 在 clean exact commit 上同时通过 CuPy 与 Torch CUDA；该 runner 是 correctness/provenance gate，而不是性能 benchmark，并会同时复核 Stage-A 的 coef/BSE/t/p/CI/df contract。 +Stage B 增加 maintained analytic/fitted-model regression tests、formula/missing-row alignment、Python 3.9 + Torch 2.0 CPU parity，以及可执行的 `linearmodels==7.0` external-definition gate。physical runner 每个 backend 包含 17 个 estimator cases 与 4 个 Hausman diagnostic cases，其中包括 balanced/unbalanced 显式常数 RandomEffects，以及 FE 吸收 intercept、RE 显式估计 intercept 的 Hausman 参数化。最终 promotion 要求 `dev/benchmarks/validate_panel_stage_b_gpu.py` 在 clean exact commit 上同时通过 CuPy 与 Torch CUDA；该 runner 是 correctness/provenance gate，而不是性能 benchmark。另有独立 physical benchmark 用于测量 Hausman-compatible FE/RE 上剩余 full-content identity 开销。 ## 参考文献 @@ -364,4 +369,4 @@ Stage B 增加 maintained analytic/fitted-model regression tests、formula/missi - White, H. (1980). A heteroskedasticity-consistent covariance matrix estimator. - Newey, W. K., & West, K. D. (1987). A simple, positive semi-definite, heteroskedasticity and autocorrelation consistent covariance matrix. - Fama, E. F., & MacBeth, J. D. (1973). Risk, return, and equilibrium. -- Cameron, A. C., Gelbach, J. B., & Miller, D. L. (2011). Robust inference with multiway clustering. \ No newline at end of file +- Cameron, A. C., Gelbach, J. B., & Miller, D. L. (2011). Robust inference with multiway clustering. From faa95ce7fb5cb204088957fbda5544c20a06fbfc Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 22:29:16 +0800 Subject: [PATCH 085/165] fix: stabilize explicit-constant random effects across backends --- ...age_b_random_effects_backend_regression.py | 72 +++++++++++++++++++ statgpu/panel/_random_effects.py | 48 ++++++++++--- 2 files changed, 112 insertions(+), 8 deletions(-) create mode 100644 dev/tests/test_panel_stage_b_random_effects_backend_regression.py diff --git a/dev/tests/test_panel_stage_b_random_effects_backend_regression.py b/dev/tests/test_panel_stage_b_random_effects_backend_regression.py new file mode 100644 index 000000000..cddfae34b --- /dev/null +++ b/dev/tests/test_panel_stage_b_random_effects_backend_regression.py @@ -0,0 +1,72 @@ +"""Regression coverage for backend-stable explicit-constant RandomEffects.""" + +from __future__ import annotations + +import numpy as np +import pytest +from numpy.testing import assert_allclose + +from dev.benchmarks.validate_panel_stage_b_gpu import _dataset +from statgpu.panel import RandomEffects + + +@pytest.mark.parametrize("unbalanced", [False, True]) +def test_explicit_constant_re_does_not_depend_on_singular_solve_exception( + monkeypatch, + unbalanced, +): + """The within auxiliary fit must never solve a structural singular system. + + An explicit level constant is annihilated by entity demeaning. NumPy raises + on the resulting singular normal equations, but some GPU linalg stacks may + return a value or warning instead. Simulate that non-raising behavior and + require RandomEffects to avoid the singular solve entirely. + """ + X, y, entity, _ = _dataset( + 20260808 + int(unbalanced), + unbalanced=unbalanced, + ) + X_constant = np.column_stack([np.ones(X.shape[0]), X]) + + expected = RandomEffects(device="cpu").fit( + X_constant, + y, + entity_ids=entity, + ) + + original_solve = np.linalg.solve + singular_calls = [] + + def nonraising_solve(A, b): + A = np.asarray(A) + if A.ndim == 2 and A.shape[0] == A.shape[1]: + rank = np.linalg.matrix_rank(A) + if rank < A.shape[0]: + singular_calls.append((A.shape, int(rank))) + # Emulate a backend that does not raise on a singular solve. + return np.zeros_like(np.asarray(b), dtype=np.float64) + return original_solve(A, b) + + monkeypatch.setattr(np.linalg, "solve", nonraising_solve) + actual = RandomEffects(device="cpu").fit( + X_constant, + y, + entity_ids=entity, + ) + + assert singular_calls == [] + assert_allclose(actual.coef_, expected.coef_, rtol=1e-11, atol=1e-12) + assert_allclose(actual.bse_, expected.bse_, rtol=1e-11, atol=1e-12) + assert_allclose( + actual.variance_components_["sigma2_e"], + expected.variance_components_["sigma2_e"], + rtol=1e-12, + atol=1e-14, + ) + assert_allclose( + actual.variance_components_["sigma2_a"], + expected.variance_components_["sigma2_a"], + rtol=1e-12, + atol=1e-14, + ) + assert_allclose(actual.theta_, expected.theta_, rtol=1e-12, atol=1e-14) diff --git a/statgpu/panel/_random_effects.py b/statgpu/panel/_random_effects.py index cd667d896..e3ad27cf5 100644 --- a/statgpu/panel/_random_effects.py +++ b/statgpu/panel/_random_effects.py @@ -162,13 +162,45 @@ def fit( for j in range(k): X_within[:, j] = within_transform(X_arr[:, j], entity_arr, xp=xp) - XtX_w = X_within.T @ X_within - Xty_w = X_within.T @ y_within - try: - beta_within = xp.linalg.solve(XtX_w, Xty_w) - except _LINALG_ERRORS: - beta_within = xp.linalg.pinv(XtX_w) @ Xty_w - resid_within = y_within - X_within @ beta_within + # An explicit level constant is annihilated exactly by the within + # transform. Passing that structural zero column into a normal-equation + # solve makes XtX singular. NumPy reliably raises LinAlgError here, while + # GPU linalg stacks may return a value or warning instead, which can make + # sigma2_e/theta/backend coefficients diverge. Remove the known null + # column and compute the same auxiliary least-squares RSS on the slope + # subspace. The df formula below is unchanged: k includes the explicit + # constant while the (N - 1) nuisance count uses the equivalent + # parameterization, so n - k - (N - 1) = n - n_slopes - N. + if constant_index is not None: + slope_indices = np.asarray( + [j for j in range(k) if j != int(constant_index)], + dtype=np.int64, + ) + if slope_indices.size == 0: + resid_within = y_within + else: + slope_idx_dev = xp_asarray( + slope_indices, + dtype=xp.int64, + xp=xp, + ref_arr=X_arr, + ) + X_within_fit = X_within[:, slope_idx_dev] + XtX_w = X_within_fit.T @ X_within_fit + Xty_w = X_within_fit.T @ y_within + # Use the small-matrix pseudoinverse deliberately in this + # structural-rank branch so correctness does not depend on + # backend-specific singular-solve exception semantics. + beta_within = xp.linalg.pinv(XtX_w) @ Xty_w + resid_within = y_within - X_within_fit @ beta_within + else: + XtX_w = X_within.T @ X_within + Xty_w = X_within.T @ y_within + try: + beta_within = xp.linalg.solve(XtX_w, Xty_w) + except _LINALG_ERRORS: + beta_within = xp.linalg.pinv(XtX_w) @ Xty_w + resid_within = y_within - X_within @ beta_within rss_within = float(xp.sum(resid_within ** 2)) # --- Step 3: Swamy-Arora variance components --- @@ -370,4 +402,4 @@ def set_params(self, **params): return self -RandomEffectsOLS = RandomEffects \ No newline at end of file +RandomEffectsOLS = RandomEffects From 806789ac7c1f71d7c91656b86dad91ab0f103582 Mon Sep 17 00:00:00 2001 From: TheHiddenObserver Date: Sat, 8 Aug 2026 23:10:16 +0800 Subject: [PATCH 086/165] benchmark: record PR122 P100 Stage B validation faa95ce7 --- ...panel_stage_b_gpu_validation_faa95ce7.json | 829 ++++++++++++++++++ 1 file changed, 829 insertions(+) create mode 100644 results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json diff --git a/results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json b/results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json new file mode 100644 index 000000000..f525ce5c8 --- /dev/null +++ b/results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json @@ -0,0 +1,829 @@ +{ + "schema_version": 2, + "generated_at": "2026-08-08T14:49:33.405711Z", + "git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "working_tree_clean": true, + "status": "success", + "environment": { + "python": "3.9.16", + "platform": "Linux-3.10.0-1062.el7.x86_64-x86_64-with-glibc2.31", + "gpu": "Tesla P100-SXM2-16GB", + "packages": { + "statgpu": "0.2.4", + "numpy": "1.24.2", + "scipy": "1.10.1", + "cupy": null, + "torch": "2.0.0" + } + }, + "tolerances": { + "rtol": 5e-06, + "atol": 5e-07 + }, + "datasets": { + "balanced": { + "nobs": 54 + }, + "unbalanced": { + "nobs": 49 + } + }, + "backends": { + "cupy": { + "models": { + "pooled_balanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 5.551115123125783e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 7.105427357601002e-15, + "pvalues": 4.440892098500626e-15, + "conf_int": 6.661338147750939e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 1.1102230246251565e-16, + "fit_statistics.rsquared_between": 7.771561172376096e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 1.4210854715202004e-14, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 1.734723475976807e-18, + "bp_lm.statistic": 1.4210854715202004e-13, + "bp_lm.pvalue": 1.0908587575630828e-35 + } + }, + "pooled_hac_unsorted_balanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 5.551115123125783e-16, + "bse": 2.7755575615628914e-17, + "tvalues": 1.0658141036401503e-14, + "pvalues": 1.1964340379966992e-20, + "conf_int": 6.661338147750939e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 2.220446049250313e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 1.4210854715202004e-14, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 3.469446951953614e-18, + "bp_lm.statistic": 7.105427357601002e-14, + "bp_lm.pvalue": 4.8430367253878245e-36 + } + }, + "between_balanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 5.551115123125783e-17, + "bse": 5.551115123125783e-17, + "tvalues": 4.440892098500626e-16, + "pvalues": 2.7755575615628914e-16, + "conf_int": 1.6653345369377348e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 0.0, + "fit_statistics.rsquared_overall": 3.3306690738754696e-16, + "fit_statistics.rsquared_adj": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 0.0, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 2.7755575615628914e-17 + } + }, + "first_difference_balanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 6.938893903907228e-18, + "tvalues": 0.0, + "pvalues": 1.9665546849844295e-156, + "conf_int": 1.1102230246251565e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 5.684341886080801e-13, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 4.336808689942018e-19 + } + }, + "panel_entity_balanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 0.0, + "bse": 6.938893903907228e-18, + "tvalues": 7.105427357601002e-15, + "pvalues": 0.0, + "conf_int": 1.1102230246251565e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 2.220446049250313e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 1.1368683772161603e-13, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 4.336808689942018e-19, + "pooling_f.statistic": 2.1316282072803006e-14, + "pooling_f.pvalue": 0.0 + } + }, + "random_effects_balanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 7.105427357601002e-15, + "pvalues": 0.0, + "conf_int": 1.1102230246251565e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 0.0, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 5.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 8.673617379884035e-19, + "random_effects_diagnostic_contract": 0.0 + } + }, + "random_effects_explicit_constant_balanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 9.71445146547012e-17, + "bse": 1.3877787807814457e-17, + "tvalues": 3.552713678800501e-15, + "pvalues": 4.440892098500626e-16, + "conf_int": 1.1102230246251565e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 0.0, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 0.0, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 1.734723475976807e-18, + "random_effects_diagnostic_contract": 0.0 + } + }, + "fama_macbeth_balanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 3.552713678800501e-15, + "pvalues": 5.421010862427522e-18, + "conf_int": 2.220446049250313e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 2.220446049250313e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 0.0, + "fit_statistics.f_pvalue": 0.0 + } + }, + "panel_two_way_balanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 3.3306690738754696e-16, + "bse": 0.0, + "tvalues": 7.105427357601002e-15, + "pvalues": 0.0, + "conf_int": 3.3306690738754696e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 2.220446049250313e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 5.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 4.0657581468206416e-20, + "pooling_f.statistic": 0.0, + "pooling_f.pvalue": 0.0 + } + }, + "pooled_unbalanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 0.0, + "tvalues": 3.552713678800501e-15, + "pvalues": 1.9984014443252818e-15, + "conf_int": 2.220446049250313e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 0.0, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 1.4210854715202004e-14, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 1.0842021724855044e-19, + "bp_lm.statistic": 2.842170943040401e-14, + "bp_lm.pvalue": 1.7333369499485123e-33 + } + }, + "pooled_hac_unsorted_unbalanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 4.996003610813204e-16, + "bse": 2.7755575615628914e-17, + "tvalues": 5.995204332975845e-15, + "pvalues": 3.3306690738754696e-15, + "conf_int": 5.551115123125783e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 1.1102230246251565e-16, + "fit_statistics.rsquared_between": 2.220446049250313e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 2.842170943040401e-14, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 4.0115480381963664e-18, + "bp_lm.statistic": 0.0, + "bp_lm.pvalue": 0.0 + } + }, + "between_unbalanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 2.7755575615628914e-17, + "tvalues": 2.220446049250313e-16, + "pvalues": 1.1102230246251565e-16, + "conf_int": 4.440892098500626e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 1.1102230246251565e-16, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 2.220446049250313e-16, + "fit_statistics.f_statistic": 7.771561172376096e-16, + "fit_statistics.f_pvalue": 3.3306690738754696e-16, + "diagnostic_covariance": 5.551115123125783e-17 + } + }, + "first_difference_unbalanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 0.0, + "bse": 3.469446951953614e-18, + "tvalues": 7.105427357601002e-15, + "pvalues": 6.9283089726601085e-121, + "conf_int": 0.0, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 1.1368683772161603e-13, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 1.0842021724855044e-19 + } + }, + "panel_entity_unbalanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 6.938893903907228e-18, + "tvalues": 0.0, + "pvalues": 0.0, + "conf_int": 2.220446049250313e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 2.2737367544323206e-13, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 3.2526065174565133e-19, + "pooling_f.statistic": 7.105427357601002e-15, + "pooling_f.pvalue": 0.0 + } + }, + "random_effects_unbalanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 6.938893903907228e-18, + "tvalues": 5.329070518200751e-15, + "pvalues": 0.0, + "conf_int": 1.1102230246251565e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 2.2737367544323206e-13, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 2.168404344971009e-19, + "random_effects_diagnostic_contract": 0.0 + } + }, + "random_effects_explicit_constant_unbalanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 4.163336342344337e-17, + "bse": 1.3877787807814457e-17, + "tvalues": 7.105427357601002e-15, + "pvalues": 0.0, + "conf_int": 8.326672684688674e-17, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 2.220446049250313e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 5.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 3.469446951953614e-18, + "random_effects_diagnostic_contract": 0.0 + } + }, + "fama_macbeth_unbalanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 5.551115123125783e-17, + "tvalues": 5.329070518200751e-15, + "pvalues": 2.220446049250313e-16, + "conf_int": 4.440892098500626e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 1.1102230246251565e-16, + "fit_statistics.rsquared_between": 0.0, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 0.0, + "fit_statistics.f_pvalue": 0.0 + } + } + }, + "diagnostics": { + "hausman_balanced": { + "status": "success", + "max_abs_differences": { + "statistic": 0.0, + "pvalue": 0.0 + }, + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_explicit_re_constant_balanced": { + "status": "success", + "max_abs_differences": { + "statistic": 0.0, + "pvalue": 0.0 + }, + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_unbalanced": { + "status": "success", + "max_abs_differences": { + "statistic": 0.0, + "pvalue": 0.0 + }, + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_explicit_re_constant_unbalanced": { + "status": "success", + "max_abs_differences": { + "statistic": 0.0, + "pvalue": 0.0 + }, + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + } + } + }, + "torch": { + "models": { + "pooled_balanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 6.661338147750939e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 8.881784197001252e-15, + "pvalues": 1.1275609692606992e-06, + "conf_int": 1.6652982326448296e-09, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 1.1102230246251565e-16, + "fit_statistics.rsquared_between": 1.1102230246251565e-15, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 1.4210854715202004e-14, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 1.734723475976807e-18, + "bp_lm.statistic": 2.4158453015843406e-13, + "bp_lm.pvalue": 1.9325127127518407e-35 + } + }, + "pooled_hac_unsorted_balanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 6.661338147750939e-16, + "bse": 2.7755575615628914e-17, + "tvalues": 1.0658141036401503e-14, + "pvalues": 1.7470054537119944e-20, + "conf_int": 6.661338147750939e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 1.1102230246251565e-16, + "fit_statistics.rsquared_between": 3.3306690738754696e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 1.4210854715202004e-14, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 3.903127820947816e-18, + "bp_lm.statistic": 1.7053025658242404e-13, + "bp_lm.pvalue": 1.3259576277275403e-35 + } + }, + "between_balanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 5.551115123125783e-17, + "bse": 1.6653345369377348e-16, + "tvalues": 8.881784197001252e-16, + "pvalues": 2.7755575615628914e-16, + "conf_int": 2.7755575615628914e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 2.220446049250313e-16, + "fit_statistics.rsquared_overall": 2.220446049250313e-16, + "fit_statistics.rsquared_adj": 2.220446049250313e-16, + "fit_statistics.f_statistic": 1.7763568394002505e-15, + "fit_statistics.f_pvalue": 3.3306690738754696e-16, + "diagnostic_covariance": 8.326672684688674e-17 + } + }, + "first_difference_balanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 0.0, + "bse": 1.3877787807814457e-17, + "tvalues": 1.4210854715202004e-14, + "pvalues": 8.539945807941643e-156, + "conf_int": 5.551115123125783e-17, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 3.3306690738754696e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 3.410605131648481e-13, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 7.589415207398531e-19 + } + }, + "panel_entity_balanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 3.469446951953614e-18, + "tvalues": 3.552713678800501e-15, + "pvalues": 0.0, + "conf_int": 4.719586943480181e-10, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 3.3306690738754696e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 1.1368683772161603e-13, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 2.168404344971009e-19, + "pooling_f.statistic": 7.105427357601002e-15, + "pooling_f.pvalue": 0.0 + } + }, + "random_effects_balanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 0.0, + "tvalues": 3.552713678800501e-15, + "pvalues": 0.0, + "conf_int": 6.353757520116687e-10, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 0.0, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 0.0, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 2.168404344971009e-19, + "random_effects_diagnostic_contract": 0.0 + } + }, + "random_effects_explicit_constant_balanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 1.3877787807814457e-17, + "bse": 1.3877787807814457e-17, + "tvalues": 3.552713678800501e-15, + "pvalues": 2.841572954714877e-08, + "conf_int": 1.8457834149998575e-09, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 4.440892098500626e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 1.7053025658242404e-13, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 1.734723475976807e-18, + "random_effects_diagnostic_contract": 0.0 + } + }, + "fama_macbeth_balanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 5.551115123125783e-17, + "bse": 1.3877787807814457e-17, + "tvalues": 1.7763568394002505e-15, + "pvalues": 3.2526065174565133e-18, + "conf_int": 1.1102230246251565e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 0.0, + "fit_statistics.rsquared_overall": 2.220446049250313e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 0.0, + "fit_statistics.f_pvalue": 0.0 + } + }, + "panel_two_way_balanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 3.3306690738754696e-16, + "bse": 6.938893903907228e-18, + "tvalues": 3.552713678800501e-15, + "pvalues": 0.0, + "conf_int": 4.125351171779812e-10, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 3.3306690738754696e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 5.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 2.168404344971009e-19, + "pooling_f.statistic": 1.4210854715202004e-14, + "pooling_f.pvalue": 0.0 + } + }, + "pooled_unbalanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 4.0245584642661925e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 5.329070518200751e-15, + "pvalues": 6.327377473080986e-07, + "conf_int": 1.3248322994208195e-09, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 0.0, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 1.734723475976807e-18, + "bp_lm.statistic": 9.947598300641403e-14, + "bp_lm.pvalue": 6.0426052005149525e-33 + } + }, + "pooled_hac_unsorted_unbalanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 6.106226635438361e-16, + "bse": 2.7755575615628914e-17, + "tvalues": 9.2148511043888e-15, + "pvalues": 4.9960036108132044e-15, + "conf_int": 6.38378239159465e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 1.1102230246251565e-16, + "fit_statistics.rsquared_between": 0.0, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 2.842170943040401e-14, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 5.366800753803247e-18, + "bp_lm.statistic": 2.842170943040401e-14, + "bp_lm.pvalue": 1.7333369499485123e-33 + } + }, + "between_unbalanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 0.0, + "tvalues": 2.220446049250313e-16, + "pvalues": 1.1102230246251565e-16, + "conf_int": 4.440892098500626e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 2.220446049250313e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 4.440892098500626e-16, + "fit_statistics.f_statistic": 1.4432899320127035e-15, + "fit_statistics.f_pvalue": 5.551115123125783e-16, + "diagnostic_covariance": 6.938893903907228e-17 + } + }, + "first_difference_unbalanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 0.0, + "bse": 6.938893903907228e-18, + "tvalues": 2.1316282072803006e-14, + "pvalues": 6.9283089726601085e-121, + "conf_int": 0.0, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 0.0, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 1.1368683772161603e-13, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 2.710505431213761e-19 + } + }, + "panel_entity_unbalanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 3.469446951953614e-18, + "tvalues": 1.4210854715202004e-14, + "pvalues": 0.0, + "conf_int": 2.8987834355120867e-10, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 2.220446049250313e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 3.410605131648481e-13, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 2.168404344971009e-19, + "pooling_f.statistic": 7.105427357601002e-15, + "pooling_f.pvalue": 0.0 + } + }, + "random_effects_unbalanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 0.0, + "tvalues": 3.552713678800501e-15, + "pvalues": 0.0, + "conf_int": 5.262852376120009e-10, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 0.0, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 0.0, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 0.0, + "random_effects_diagnostic_contract": 0.0 + } + }, + "random_effects_explicit_constant_unbalanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 1.4210854715202004e-14, + "pvalues": 2.1985840481519858e-08, + "conf_int": 1.818750788862289e-09, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 3.3306690738754696e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 1.1368683772161603e-13, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 1.734723475976807e-18, + "random_effects_diagnostic_contract": 0.0 + } + }, + "fama_macbeth_unbalanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 4.440892098500626e-16, + "bse": 8.326672684688674e-17, + "tvalues": 5.329070518200751e-15, + "pvalues": 1.6263032587282567e-19, + "conf_int": 6.661338147750939e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 1.1102230246251565e-16, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 2.220446049250313e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 0.0, + "fit_statistics.f_pvalue": 0.0 + } + } + }, + "diagnostics": { + "hausman_balanced": { + "status": "success", + "max_abs_differences": { + "statistic": 0.0, + "pvalue": 0.0 + }, + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_explicit_re_constant_balanced": { + "status": "success", + "max_abs_differences": { + "statistic": 0.0, + "pvalue": 0.0 + }, + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_unbalanced": { + "status": "success", + "max_abs_differences": { + "statistic": 0.0, + "pvalue": 0.0 + }, + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_explicit_re_constant_unbalanced": { + "status": "success", + "max_abs_differences": { + "statistic": 0.0, + "pvalue": 0.0 + }, + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + } + } + } + } +} From e9e9cbd9d862fb483ab9720422457dce2b5e02c7 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 23:31:21 +0800 Subject: [PATCH 087/165] fix: distinguish PR122 Hausman physical variants --- .../frontend_data/parsers/panel_stage_b.py | 25 ++++++++++++++++--- 1 file changed, 21 insertions(+), 4 deletions(-) diff --git a/dev/benchmarks/frontend_data/parsers/panel_stage_b.py b/dev/benchmarks/frontend_data/parsers/panel_stage_b.py index 8aa096f1e..5f19c1215 100644 --- a/dev/benchmarks/frontend_data/parsers/panel_stage_b.py +++ b/dev/benchmarks/frontend_data/parsers/panel_stage_b.py @@ -135,6 +135,17 @@ def parse_panel_stage_b_physical_validation( for diagnostic_id, diagnostic in backend_result.get("diagnostics", {}).items(): balance = "unbalanced" if diagnostic_id.endswith("unbalanced") else "balanced" + explicit_re_constant = diagnostic_id.startswith( + "hausman_explicit_re_constant_" + ) + parameterization = ( + "re-explicit-constant" if explicit_re_constant else "standard" + ) + variant = ( + f"hausman-re-explicit-constant-{balance}" + if explicit_re_constant + else f"hausman-{balance}" + ) n_samples = 49 if balance == "unbalanced" else 54 scale = { "scale_key": make_scale_key(n_samples, 2), @@ -154,6 +165,13 @@ def parse_panel_stage_b_physical_validation( "status": "fail", } ) + method_parts: list[object] = [ + "panel-stage-b-physical-validation", + "hausman", + balance, + ] + if explicit_re_constant: + method_parts.append(parameterization) model_ids.add("PanelOLS") runs.append( { @@ -163,10 +181,8 @@ def parse_panel_stage_b_physical_validation( "category_ids": ["panel"], "model_id": "PanelOLS", "case_id": _stable_id("case", diagnostic_id, scale["scale_key"]), - "method_config_id": _stable_id( - "method", "panel-stage-b-physical-validation", "hausman", balance - ), - "variant": f"hausman-{balance}", + "method_config_id": _stable_id("method", *method_parts), + "variant": variant, "penalty": None, "solver": "physical_validation", "solver_display": "Physical validation", @@ -177,6 +193,7 @@ def parse_panel_stage_b_physical_validation( "parameters": { "metric_scope": "physical_validation", "diagnostic": "hausman", + "parameterization": parameterization, "applicable": bool(diagnostic.get("applicable")), "measurement_git_sha": data.get("git_sha"), "working_tree_clean": bool(data.get("working_tree_clean")), From ae37fe137b3f603996ae4ca7add74c8b68857e6c Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 23:31:54 +0800 Subject: [PATCH 088/165] benchmark: refresh PR122 canonical P100 evidence --- .../panel_stage_b_pr122_p100_20260808.json | 212 +++++++----------- 1 file changed, 85 insertions(+), 127 deletions(-) diff --git a/results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260808.json b/results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260808.json index 803b53b21..c6a372170 100644 --- a/results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260808.json +++ b/results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260808.json @@ -2,16 +2,27 @@ "method": "Panel Tier-1 Stage B physical GPU validation", "source_schema_version": "1.0", "source_date": "2026-08-08", - "git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true, "status": "success", + "raw_artifact": { + "path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "c1ba014a3b9bb0d32cbc0ca3d844ccfe767e7149189efb9ba2969f5bc1b94b31", + "repository_commit": "806789ac7c1f71d7c91656b86dad91ab0f103582", + "generated_at": "2026-08-08T14:49:33.405711Z", + "schema_version": 2 + }, "environment": { "env_id": "remote-p100-pr122-20260808", - "gpu": "Tesla P100", + "gpu": "Tesla P100-SXM2-16GB", "cpu": "x86_64", + "platform": "Linux-3.10.0-1062.el7.x86_64-x86_64-with-glibc2.31", "python": "3.9.16", "packages": { - "cupy": "13.6.0", + "statgpu": "0.2.4", + "numpy": "1.24.2", + "scipy": "1.10.1", + "cupy": null, "torch": "2.0.0" }, "available_backends": [ @@ -25,7 +36,9 @@ "reference_backend": "numpy", "dtype": "float64", "timing_collected": false, - "failure_policy": "fail_on_backend_mismatch_or_precision_regression" + "failure_policy": "fail_on_backend_mismatch_or_precision_regression", + "rtol": 5e-06, + "atol": 5e-07 }, "backend_times": { "numpy": null, @@ -43,16 +56,30 @@ "cupy": "pass", "torch": "pass" }, + "precision_summary": { + "max_coef_abs_difference": { + "cupy": 5.551115123125783e-16, + "torch": 6.661338147750939e-16 + }, + "explicit_constant_re_max_coef_abs_difference": { + "cupy": 9.71445146547012e-17, + "torch": 2.220446049250313e-16 + }, + "random_effects_diagnostic_contract_max_difference": { + "cupy": 0.0, + "torch": 0.0 + } + }, "compatibility_matrix": { "cupy": { - "model_cases": "15/15", - "diagnostics": "2/2", + "model_cases": "17/17", + "diagnostics": "4/4", "executed_backend": "cupy", "cpu_fallback": false }, "torch": { - "model_cases": "15/15", - "diagnostics": "2/2", + "model_cases": "17/17", + "diagnostics": "4/4", "executed_backend": "torch", "cpu_fallback": false } @@ -70,7 +97,7 @@ "df_resid" ], "reference": "statgpu NumPy", - "reported_precision": "machine-epsilon scale" + "reported_precision": "all checks within validator tolerances; coefficient differences are at machine-epsilon scale" }, "threshold_source": { "stage_b": "validator-defined backend parity tolerances", @@ -90,13 +117,16 @@ "reason": "Correctness/backend-provenance validation only; no benchmark timing was measured." }, "reproducibility": { - "exact_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "exact_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true, - "runner": "dev/benchmarks/validate_panel_stage_b_gpu.py" + "runner": "dev/benchmarks/validate_panel_stage_b_gpu.py", + "raw_artifact_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "raw_artifact_sha256": "c1ba014a3b9bb0d32cbc0ca3d844ccfe767e7149189efb9ba2969f5bc1b94b31" }, "uncovered_reasons": [ "Performance timing was not collected by this correctness-only physical validation and must not be inferred from this artifact.", - "Hausman was consistently inapplicable for the generated balanced and unbalanced validation datasets; applicability consistency, not a fabricated statistic, is recorded." + "All standard and explicit-RE-constant Hausman validation datasets produced materially indefinite covariance differences; applicability/reason parity against NumPy, not a fabricated statistic, is recorded.", + "The runner could not resolve an installed CuPy distribution version through importlib.metadata, so the canonical source records the CuPy package version as null while preserving executed_backend='cupy' as physical backend provenance." ], "case_catalog": [ { @@ -105,13 +135,7 @@ "variant": "balanced", "n_samples": 54, "n_features": 2, - "checks": [ - "fit_statistics", - "bp_lm", - "diagnostic_covariance", - "stage_a_inference", - "backend_provenance" - ] + "checks": ["fit_statistics", "bp_lm", "diagnostic_covariance", "stage_a_inference", "backend_provenance"] }, { "case_id": "pooled_hac_unsorted_balanced", @@ -119,14 +143,7 @@ "variant": "balanced-hac-unsorted", "n_samples": 54, "n_features": 2, - "checks": [ - "fit_statistics", - "bp_lm", - "diagnostic_covariance", - "stage_a_inference", - "metadata_sort_alignment", - "backend_provenance" - ] + "checks": ["fit_statistics", "bp_lm", "diagnostic_covariance", "stage_a_inference", "metadata_sort_alignment", "backend_provenance"] }, { "case_id": "between_balanced", @@ -134,12 +151,7 @@ "variant": "balanced", "n_samples": 54, "n_features": 2, - "checks": [ - "fit_statistics", - "diagnostic_covariance", - "stage_a_inference", - "backend_provenance" - ] + "checks": ["fit_statistics", "diagnostic_covariance", "stage_a_inference", "backend_provenance"] }, { "case_id": "first_difference_balanced", @@ -147,12 +159,7 @@ "variant": "balanced", "n_samples": 54, "n_features": 2, - "checks": [ - "fit_statistics", - "diagnostic_covariance", - "stage_a_inference", - "backend_provenance" - ] + "checks": ["fit_statistics", "diagnostic_covariance", "stage_a_inference", "backend_provenance"] }, { "case_id": "panel_entity_balanced", @@ -160,13 +167,7 @@ "variant": "entity-fe-balanced", "n_samples": 54, "n_features": 2, - "checks": [ - "fit_statistics", - "pooling_f", - "diagnostic_covariance", - "stage_a_inference", - "backend_provenance" - ] + "checks": ["fit_statistics", "pooling_f", "diagnostic_covariance", "stage_a_inference", "backend_provenance"] }, { "case_id": "random_effects_balanced", @@ -174,12 +175,15 @@ "variant": "balanced", "n_samples": 54, "n_features": 2, - "checks": [ - "fit_statistics", - "diagnostic_covariance", - "stage_a_inference", - "backend_provenance" - ] + "checks": ["fit_statistics", "diagnostic_covariance", "stage_a_inference", "random_effects_diagnostic_contract", "backend_provenance"] + }, + { + "case_id": "random_effects_explicit_constant_balanced", + "model_id": "RandomEffects", + "variant": "explicit-constant-balanced", + "n_samples": 54, + "n_features": 3, + "checks": ["fit_statistics", "diagnostic_covariance", "stage_a_inference", "random_effects_diagnostic_contract", "backend_provenance"] }, { "case_id": "fama_macbeth_balanced", @@ -187,12 +191,7 @@ "variant": "balanced", "n_samples": 54, "n_features": 2, - "checks": [ - "fit_statistics", - "diagnostic_covariance", - "stage_a_inference", - "backend_provenance" - ] + "checks": ["fit_statistics", "diagnostic_covariance", "stage_a_inference", "backend_provenance"] }, { "case_id": "panel_two_way_balanced", @@ -200,13 +199,7 @@ "variant": "two-way-fe-balanced", "n_samples": 54, "n_features": 2, - "checks": [ - "fit_statistics", - "pooling_f", - "diagnostic_covariance", - "stage_a_inference", - "backend_provenance" - ] + "checks": ["fit_statistics", "pooling_f", "diagnostic_covariance", "stage_a_inference", "backend_provenance"] }, { "case_id": "pooled_unbalanced", @@ -214,13 +207,7 @@ "variant": "unbalanced", "n_samples": 49, "n_features": 2, - "checks": [ - "fit_statistics", - "bp_lm", - "diagnostic_covariance", - "stage_a_inference", - "backend_provenance" - ] + "checks": ["fit_statistics", "bp_lm", "diagnostic_covariance", "stage_a_inference", "backend_provenance"] }, { "case_id": "pooled_hac_unsorted_unbalanced", @@ -228,14 +215,7 @@ "variant": "unbalanced-hac-unsorted", "n_samples": 49, "n_features": 2, - "checks": [ - "fit_statistics", - "bp_lm", - "diagnostic_covariance", - "stage_a_inference", - "metadata_sort_alignment", - "backend_provenance" - ] + "checks": ["fit_statistics", "bp_lm", "diagnostic_covariance", "stage_a_inference", "metadata_sort_alignment", "backend_provenance"] }, { "case_id": "between_unbalanced", @@ -243,12 +223,7 @@ "variant": "unbalanced", "n_samples": 49, "n_features": 2, - "checks": [ - "fit_statistics", - "diagnostic_covariance", - "stage_a_inference", - "backend_provenance" - ] + "checks": ["fit_statistics", "diagnostic_covariance", "stage_a_inference", "backend_provenance"] }, { "case_id": "first_difference_unbalanced", @@ -256,12 +231,7 @@ "variant": "unbalanced", "n_samples": 49, "n_features": 2, - "checks": [ - "fit_statistics", - "diagnostic_covariance", - "stage_a_inference", - "backend_provenance" - ] + "checks": ["fit_statistics", "diagnostic_covariance", "stage_a_inference", "backend_provenance"] }, { "case_id": "panel_entity_unbalanced", @@ -269,13 +239,7 @@ "variant": "entity-fe-unbalanced", "n_samples": 49, "n_features": 2, - "checks": [ - "fit_statistics", - "pooling_f", - "diagnostic_covariance", - "stage_a_inference", - "backend_provenance" - ] + "checks": ["fit_statistics", "pooling_f", "diagnostic_covariance", "stage_a_inference", "backend_provenance"] }, { "case_id": "random_effects_unbalanced", @@ -283,12 +247,15 @@ "variant": "unbalanced", "n_samples": 49, "n_features": 2, - "checks": [ - "fit_statistics", - "diagnostic_covariance", - "stage_a_inference", - "backend_provenance" - ] + "checks": ["fit_statistics", "diagnostic_covariance", "stage_a_inference", "random_effects_diagnostic_contract", "backend_provenance"] + }, + { + "case_id": "random_effects_explicit_constant_unbalanced", + "model_id": "RandomEffects", + "variant": "explicit-constant-unbalanced", + "n_samples": 49, + "n_features": 3, + "checks": ["fit_statistics", "diagnostic_covariance", "stage_a_inference", "random_effects_diagnostic_contract", "backend_provenance"] }, { "case_id": "fama_macbeth_unbalanced", @@ -296,12 +263,7 @@ "variant": "unbalanced", "n_samples": 49, "n_features": 2, - "checks": [ - "fit_statistics", - "diagnostic_covariance", - "stage_a_inference", - "backend_provenance" - ] + "checks": ["fit_statistics", "diagnostic_covariance", "stage_a_inference", "backend_provenance"] } ], "backend_results": { @@ -315,6 +277,7 @@ "first_difference_balanced": "success", "panel_entity_balanced": "success", "random_effects_balanced": "success", + "random_effects_explicit_constant_balanced": "success", "fama_macbeth_balanced": "success", "panel_two_way_balanced": "success", "pooled_unbalanced": "success", @@ -323,17 +286,14 @@ "first_difference_unbalanced": "success", "panel_entity_unbalanced": "success", "random_effects_unbalanced": "success", + "random_effects_explicit_constant_unbalanced": "success", "fama_macbeth_unbalanced": "success" }, "diagnostics": { - "hausman_balanced": { - "status": "success", - "applicable": false - }, - "hausman_unbalanced": { - "status": "success", - "applicable": false - } + "hausman_balanced": {"status": "success", "applicable": false, "reason": "covariance difference is not positive semidefinite"}, + "hausman_explicit_re_constant_balanced": {"status": "success", "applicable": false, "reason": "covariance difference is not positive semidefinite"}, + "hausman_unbalanced": {"status": "success", "applicable": false, "reason": "covariance difference is not positive semidefinite"}, + "hausman_explicit_re_constant_unbalanced": {"status": "success", "applicable": false, "reason": "covariance difference is not positive semidefinite"} } }, "torch": { @@ -346,6 +306,7 @@ "first_difference_balanced": "success", "panel_entity_balanced": "success", "random_effects_balanced": "success", + "random_effects_explicit_constant_balanced": "success", "fama_macbeth_balanced": "success", "panel_two_way_balanced": "success", "pooled_unbalanced": "success", @@ -354,17 +315,14 @@ "first_difference_unbalanced": "success", "panel_entity_unbalanced": "success", "random_effects_unbalanced": "success", + "random_effects_explicit_constant_unbalanced": "success", "fama_macbeth_unbalanced": "success" }, "diagnostics": { - "hausman_balanced": { - "status": "success", - "applicable": false - }, - "hausman_unbalanced": { - "status": "success", - "applicable": false - } + "hausman_balanced": {"status": "success", "applicable": false, "reason": "covariance difference is not positive semidefinite"}, + "hausman_explicit_re_constant_balanced": {"status": "success", "applicable": false, "reason": "covariance difference is not positive semidefinite"}, + "hausman_unbalanced": {"status": "success", "applicable": false, "reason": "covariance difference is not positive semidefinite"}, + "hausman_explicit_re_constant_unbalanced": {"status": "success", "applicable": false, "reason": "covariance difference is not positive semidefinite"} } } } From 2fedbd011e4b76400d559d2818caf1d878de955c Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 23:32:35 +0800 Subject: [PATCH 089/165] style: canonicalize PR122 physical evidence JSON --- .../panel_stage_b_pr122_p100_20260808.json | 180 +++++++++++++++--- 1 file changed, 155 insertions(+), 25 deletions(-) diff --git a/results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260808.json b/results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260808.json index c6a372170..38ed1ef01 100644 --- a/results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260808.json +++ b/results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260808.json @@ -135,7 +135,13 @@ "variant": "balanced", "n_samples": 54, "n_features": 2, - "checks": ["fit_statistics", "bp_lm", "diagnostic_covariance", "stage_a_inference", "backend_provenance"] + "checks": [ + "fit_statistics", + "bp_lm", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] }, { "case_id": "pooled_hac_unsorted_balanced", @@ -143,7 +149,14 @@ "variant": "balanced-hac-unsorted", "n_samples": 54, "n_features": 2, - "checks": ["fit_statistics", "bp_lm", "diagnostic_covariance", "stage_a_inference", "metadata_sort_alignment", "backend_provenance"] + "checks": [ + "fit_statistics", + "bp_lm", + "diagnostic_covariance", + "stage_a_inference", + "metadata_sort_alignment", + "backend_provenance" + ] }, { "case_id": "between_balanced", @@ -151,7 +164,12 @@ "variant": "balanced", "n_samples": 54, "n_features": 2, - "checks": ["fit_statistics", "diagnostic_covariance", "stage_a_inference", "backend_provenance"] + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] }, { "case_id": "first_difference_balanced", @@ -159,7 +177,12 @@ "variant": "balanced", "n_samples": 54, "n_features": 2, - "checks": ["fit_statistics", "diagnostic_covariance", "stage_a_inference", "backend_provenance"] + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] }, { "case_id": "panel_entity_balanced", @@ -167,7 +190,13 @@ "variant": "entity-fe-balanced", "n_samples": 54, "n_features": 2, - "checks": ["fit_statistics", "pooling_f", "diagnostic_covariance", "stage_a_inference", "backend_provenance"] + "checks": [ + "fit_statistics", + "pooling_f", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] }, { "case_id": "random_effects_balanced", @@ -175,7 +204,13 @@ "variant": "balanced", "n_samples": 54, "n_features": 2, - "checks": ["fit_statistics", "diagnostic_covariance", "stage_a_inference", "random_effects_diagnostic_contract", "backend_provenance"] + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "random_effects_diagnostic_contract", + "backend_provenance" + ] }, { "case_id": "random_effects_explicit_constant_balanced", @@ -183,7 +218,13 @@ "variant": "explicit-constant-balanced", "n_samples": 54, "n_features": 3, - "checks": ["fit_statistics", "diagnostic_covariance", "stage_a_inference", "random_effects_diagnostic_contract", "backend_provenance"] + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "random_effects_diagnostic_contract", + "backend_provenance" + ] }, { "case_id": "fama_macbeth_balanced", @@ -191,7 +232,12 @@ "variant": "balanced", "n_samples": 54, "n_features": 2, - "checks": ["fit_statistics", "diagnostic_covariance", "stage_a_inference", "backend_provenance"] + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] }, { "case_id": "panel_two_way_balanced", @@ -199,7 +245,13 @@ "variant": "two-way-fe-balanced", "n_samples": 54, "n_features": 2, - "checks": ["fit_statistics", "pooling_f", "diagnostic_covariance", "stage_a_inference", "backend_provenance"] + "checks": [ + "fit_statistics", + "pooling_f", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] }, { "case_id": "pooled_unbalanced", @@ -207,7 +259,13 @@ "variant": "unbalanced", "n_samples": 49, "n_features": 2, - "checks": ["fit_statistics", "bp_lm", "diagnostic_covariance", "stage_a_inference", "backend_provenance"] + "checks": [ + "fit_statistics", + "bp_lm", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] }, { "case_id": "pooled_hac_unsorted_unbalanced", @@ -215,7 +273,14 @@ "variant": "unbalanced-hac-unsorted", "n_samples": 49, "n_features": 2, - "checks": ["fit_statistics", "bp_lm", "diagnostic_covariance", "stage_a_inference", "metadata_sort_alignment", "backend_provenance"] + "checks": [ + "fit_statistics", + "bp_lm", + "diagnostic_covariance", + "stage_a_inference", + "metadata_sort_alignment", + "backend_provenance" + ] }, { "case_id": "between_unbalanced", @@ -223,7 +288,12 @@ "variant": "unbalanced", "n_samples": 49, "n_features": 2, - "checks": ["fit_statistics", "diagnostic_covariance", "stage_a_inference", "backend_provenance"] + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] }, { "case_id": "first_difference_unbalanced", @@ -231,7 +301,12 @@ "variant": "unbalanced", "n_samples": 49, "n_features": 2, - "checks": ["fit_statistics", "diagnostic_covariance", "stage_a_inference", "backend_provenance"] + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] }, { "case_id": "panel_entity_unbalanced", @@ -239,7 +314,13 @@ "variant": "entity-fe-unbalanced", "n_samples": 49, "n_features": 2, - "checks": ["fit_statistics", "pooling_f", "diagnostic_covariance", "stage_a_inference", "backend_provenance"] + "checks": [ + "fit_statistics", + "pooling_f", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] }, { "case_id": "random_effects_unbalanced", @@ -247,7 +328,13 @@ "variant": "unbalanced", "n_samples": 49, "n_features": 2, - "checks": ["fit_statistics", "diagnostic_covariance", "stage_a_inference", "random_effects_diagnostic_contract", "backend_provenance"] + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "random_effects_diagnostic_contract", + "backend_provenance" + ] }, { "case_id": "random_effects_explicit_constant_unbalanced", @@ -255,7 +342,13 @@ "variant": "explicit-constant-unbalanced", "n_samples": 49, "n_features": 3, - "checks": ["fit_statistics", "diagnostic_covariance", "stage_a_inference", "random_effects_diagnostic_contract", "backend_provenance"] + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "random_effects_diagnostic_contract", + "backend_provenance" + ] }, { "case_id": "fama_macbeth_unbalanced", @@ -263,7 +356,12 @@ "variant": "unbalanced", "n_samples": 49, "n_features": 2, - "checks": ["fit_statistics", "diagnostic_covariance", "stage_a_inference", "backend_provenance"] + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] } ], "backend_results": { @@ -290,10 +388,26 @@ "fama_macbeth_unbalanced": "success" }, "diagnostics": { - "hausman_balanced": {"status": "success", "applicable": false, "reason": "covariance difference is not positive semidefinite"}, - "hausman_explicit_re_constant_balanced": {"status": "success", "applicable": false, "reason": "covariance difference is not positive semidefinite"}, - "hausman_unbalanced": {"status": "success", "applicable": false, "reason": "covariance difference is not positive semidefinite"}, - "hausman_explicit_re_constant_unbalanced": {"status": "success", "applicable": false, "reason": "covariance difference is not positive semidefinite"} + "hausman_balanced": { + "status": "success", + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_explicit_re_constant_balanced": { + "status": "success", + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_unbalanced": { + "status": "success", + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_explicit_re_constant_unbalanced": { + "status": "success", + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + } } }, "torch": { @@ -319,10 +433,26 @@ "fama_macbeth_unbalanced": "success" }, "diagnostics": { - "hausman_balanced": {"status": "success", "applicable": false, "reason": "covariance difference is not positive semidefinite"}, - "hausman_explicit_re_constant_balanced": {"status": "success", "applicable": false, "reason": "covariance difference is not positive semidefinite"}, - "hausman_unbalanced": {"status": "success", "applicable": false, "reason": "covariance difference is not positive semidefinite"}, - "hausman_explicit_re_constant_unbalanced": {"status": "success", "applicable": false, "reason": "covariance difference is not positive semidefinite"} + "hausman_balanced": { + "status": "success", + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_explicit_re_constant_balanced": { + "status": "success", + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_unbalanced": { + "status": "success", + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_explicit_re_constant_unbalanced": { + "status": "success", + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + } } } } From eadd5f4eb61fc13fafdea577185fc20278231f03 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 23:33:10 +0800 Subject: [PATCH 090/165] benchmark: register exact-head PR122 physical evidence --- dev/benchmarks/frontend_sources.json | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/dev/benchmarks/frontend_sources.json b/dev/benchmarks/frontend_sources.json index 790db1eca..194ed50b0 100644 --- a/dev/benchmarks/frontend_sources.json +++ b/dev/benchmarks/frontend_sources.json @@ -22,7 +22,7 @@ }, "remote-p100-pr122-20260808": { "label": "Tesla P100 PR #122 Panel Stage B validation — 2026-08-08", - "gpu": "Tesla P100", + "gpu": "Tesla P100-SXM2-16GB", "cpu": "x86_64" } }, @@ -241,19 +241,20 @@ "provenance_note": "Physical PR #116 validation was executed on Tesla P100 from exact numerical implementation head e6e4846b06604ed53e65fc9afd9054bd5777098f. The artifact records that SHA directly; the historical pre-fix P100 source remains registered separately." }, { - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", "comparison_id": "panel-stage-b-pr122-20260808", "path": "results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260808.json", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba", "parser": "panel_stage_b_physical_validation", "parser_version": "1.0", "env_id": "remote-p100-pr122-20260808", "required": true, "allowed_issue_codes": [], "source_date": "2026-08-08", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", - "raw_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", - "provenance_note": "Correctness/backend-provenance source only. Tesla P100 physical validation passed on the exact clean Stage-B implementation head; no timing was collected, so the frontend must not infer timing or speedup from this source." + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "raw_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "provenance_note": "Correctness/backend-provenance source only. Raw schema-2 artifact results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json (SHA-256 c1ba014a3b9bb0d32cbc0ca3d844ccfe767e7149189efb9ba2969f5bc1b94b31) was produced from exact clean implementation head faa95ce7fb5cb204088957fbda5544c20a06fbfc on Tesla P100-SXM2-16GB. All 17 estimator cases/backend and four Hausman diagnostics/backend passed on CuPy and Torch CUDA. No timing was collected, so the frontend must not infer timing or speedup from this source." } ] } From 14fa64275267b9b538cb02de4f25dbb11c790eec Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 23:33:35 +0800 Subject: [PATCH 091/165] test: lock PR122 physical evidence provenance --- .../test_panel_stage_b_frontend_source.py | 59 +++++++++++++++---- 1 file changed, 47 insertions(+), 12 deletions(-) diff --git a/dev/tests/test_panel_stage_b_frontend_source.py b/dev/tests/test_panel_stage_b_frontend_source.py index f5631cf80..86eb1ab70 100644 --- a/dev/tests/test_panel_stage_b_frontend_source.py +++ b/dev/tests/test_panel_stage_b_frontend_source.py @@ -14,8 +14,16 @@ / "benchmark_frontend_sources" / "panel_stage_b_pr122_p100_20260808.json" ) -EXPECTED_SHA256 = "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" -SOURCE_ID = "panel-stage-b-pr122-20260808-882892c6e307" +RAW_SOURCE_PATH = ( + REPO_ROOT + / "results" + / "pr122_p100" + / "panel_stage_b_gpu_validation_faa95ce7.json" +) +EXPECTED_SHA256 = "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" +RAW_EXPECTED_SHA256 = "c1ba014a3b9bb0d32cbc0ca3d844ccfe767e7149189efb9ba2969f5bc1b94b31" +SOURCE_ID = "panel-stage-b-pr122-20260808-b8caffa6f915" +MEASUREMENT_SHA = "faa95ce7fb5cb204088957fbda5544c20a06fbfc" def test_pr122_physical_source_contract_and_hash() -> None: @@ -23,19 +31,26 @@ def test_pr122_physical_source_contract_and_hash() -> None: data = json.loads(SOURCE_PATH.read_text(encoding="utf-8")) assert source_sha256(SOURCE_PATH) == EXPECTED_SHA256 + assert source_sha256(RAW_SOURCE_PATH) == RAW_EXPECTED_SHA256 assert data["source_schema_version"] == "1.0" assert data["source_date"] == "2026-08-08" - assert data["git_sha"] == "636988751bcbfad3442d24d3073cdfcd2b3ac637" + assert data["git_sha"] == MEASUREMENT_SHA assert data["working_tree_clean"] is True assert data["status"] == "success" assert data["schema_status"] == "ok" assert data["validation_tier"] == "remote-full" assert data["protocol"]["timing_collected"] is False assert data["backend_times"] == {"numpy": None, "cupy": None, "torch": None} - assert data["compatibility_matrix"]["cupy"]["model_cases"] == "15/15" - assert data["compatibility_matrix"]["torch"]["model_cases"] == "15/15" + assert data["compatibility_matrix"]["cupy"]["model_cases"] == "17/17" + assert data["compatibility_matrix"]["torch"]["model_cases"] == "17/17" + assert data["compatibility_matrix"]["cupy"]["diagnostics"] == "4/4" + assert data["compatibility_matrix"]["torch"]["diagnostics"] == "4/4" assert data["compatibility_matrix"]["cupy"]["cpu_fallback"] is False assert data["compatibility_matrix"]["torch"]["cpu_fallback"] is False + assert data["raw_artifact"]["path"] == str(RAW_SOURCE_PATH.relative_to(REPO_ROOT)) + assert data["raw_artifact"]["sha256"] == RAW_EXPECTED_SHA256 + assert data["environment"]["gpu"] == "Tesla P100-SXM2-16GB" + assert data["environment"]["packages"]["cupy"] is None def test_pr122_parser_emits_validation_only_frontend_runs() -> None: @@ -48,7 +63,7 @@ def test_pr122_parser_emits_validation_only_frontend_runs() -> None: ) assert warnings == [] - assert len(runs) == 34 + assert len(runs) == 42 assert len(models) == 6 assert {run["backend"] for run in runs} == {"cupy", "torch"} assert {model["model_id"] for model in models} == { @@ -63,21 +78,38 @@ def test_pr122_parser_emits_validation_only_frontend_runs() -> None: assert all("speedup" not in run["metrics"] for run in runs) assert all(run["metrics"]["validation"]["status"] == "pass" for run in runs) assert all( - run["parameters"]["measurement_git_sha"] - == "636988751bcbfad3442d24d3073cdfcd2b3ac637" - for run in runs + run["parameters"]["measurement_git_sha"] == MEASUREMENT_SHA for run in runs ) assert all(run["parameters"]["working_tree_clean"] is True for run in runs) hausman = [run for run in runs if run["parameters"].get("diagnostic") == "hausman"] - assert len(hausman) == 4 + assert len(hausman) == 8 assert all(run["parameters"]["applicable"] is False for run in hausman) assert all("inference" not in run["metrics"] for run in hausman) + assert {run["parameters"]["parameterization"] for run in hausman} == { + "standard", + "re-explicit-constant", + } + assert {run["variant"] for run in hausman} == { + "hausman-balanced", + "hausman-unbalanced", + "hausman-re-explicit-constant-balanced", + "hausman-re-explicit-constant-unbalanced", + } estimator_runs = [run for run in runs if run not in hausman] - assert len(estimator_runs) == 30 + assert len(estimator_runs) == 34 assert all(run["metrics"]["inference"]["ok"] is True for run in estimator_runs) + explicit_re = [ + run + for run in estimator_runs + if run["model_id"] == "RandomEffects" + and run["variant"].startswith("explicit-constant-") + ] + assert len(explicit_re) == 4 + assert {run["scale"]["n_features"] for run in explicit_re} == {3} + def test_pr122_parser_is_registered_in_manifest() -> None: from dev.benchmarks.frontend_data.parsers import ( @@ -95,7 +127,10 @@ def test_pr122_parser_is_registered_in_manifest() -> None: assert entry["path"] == ( "results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260808.json" ) + assert entry["original_path"] == str(RAW_SOURCE_PATH.relative_to(REPO_ROOT)) assert entry["sha256"] == EXPECTED_SHA256 assert entry["parser"] == "panel_stage_b_physical_validation" assert entry["parser_version"] == "1.0" - assert entry["measurement_git_sha"] == "636988751bcbfad3442d24d3073cdfcd2b3ac637" + assert entry["measurement_git_sha"] == MEASUREMENT_SHA + assert entry["raw_git_sha"] == MEASUREMENT_SHA + assert RAW_EXPECTED_SHA256 in entry["provenance_note"] From 5b217312b1dab3940edcbe1db46b4c16ddc23c87 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 23:34:28 +0800 Subject: [PATCH 092/165] docs: record final PR122 P100 evidence --- dev/reviews/pr122_physical_gpu_validation.md | 69 +++++++++++++------- 1 file changed, 46 insertions(+), 23 deletions(-) diff --git a/dev/reviews/pr122_physical_gpu_validation.md b/dev/reviews/pr122_physical_gpu_validation.md index 554f5e6c8..5427fbe0a 100644 --- a/dev/reviews/pr122_physical_gpu_validation.md +++ b/dev/reviews/pr122_physical_gpu_validation.md @@ -1,53 +1,76 @@ # PR #122 Panel Stage B physical GPU validation -Validated implementation head: `636988751bcbfad3442d24d3073cdfcd2b3ac637`. +Validated implementation head: `faa95ce7fb5cb204088957fbda5544c20a06fbfc`. -Canonical machine-readable evidence: +Raw machine-readable evidence: + +- artifact: `results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json` +- raw SHA-256: `c1ba014a3b9bb0d32cbc0ca3d844ccfe767e7149189efb9ba2969f5bc1b94b31` +- repository commit carrying the immutable raw artifact: `806789ac7c1f71d7c91656b86dad91ab0f103582` +- runner schema: 2 +- top-level `git_sha`: `faa95ce7fb5cb204088957fbda5544c20a06fbfc` +- `working_tree_clean = true` +- `status = success` + +Canonical frontend evidence: - source: `results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260808.json` -- SHA256: `882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d` -- frontend source id: `panel-stage-b-pr122-20260808-882892c6e307` +- canonical SHA-256: `b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba` +- frontend source id: `panel-stage-b-pr122-20260808-b8caffa6f915` - parser: `panel_stage_b_physical_validation` v1.0 - evidence type: validation/correctness/backend provenance only; no timing or speedup is inferred from this source. Environment reported by the physical run: -- NVIDIA Tesla P100 +- NVIDIA Tesla P100-SXM2-16GB - Python 3.9.16 -- CuPy 13.6.0 +- statgpu 0.2.4 +- NumPy 1.24.2 +- SciPy 1.10.1 - PyTorch 2.0.0 - -Top-level artifact contract: - -- `schema_version = 2` in the physical runner output; the normalized frontend source records `runner_schema_version = 2` under its source schema v1.0 wrapper; -- `git_sha = 636988751bcbfad3442d24d3073cdfcd2b3ac637`; -- `working_tree_clean = true`; -- `status = success`. +- CuPy CUDA execution is proven by `executed_backend = cupy`; the runner's `importlib.metadata` package-version lookup returned `null`, so the canonical evidence deliberately does not fabricate a CuPy version. CuPy acceptance: -- 15/15 model cases succeeded with `executed_backend = cupy`; -- balanced and unbalanced PooledOLS, unsorted-time HAC PooledOLS, BetweenOLS, FirstDifferenceOLS, one-way PanelOLS, RandomEffects, and FamaMacBeth all succeeded; +- 17/17 estimator cases succeeded with `executed_backend = cupy`; +- all four Hausman diagnostic cases succeeded; +- balanced and unbalanced PooledOLS, unsorted-time HAC PooledOLS, BetweenOLS, FirstDifferenceOLS, one-way PanelOLS, RandomEffects, explicit-constant RandomEffects, and FamaMacBeth succeeded; - balanced two-way PanelOLS succeeded; -- balanced and unbalanced Hausman diagnostic cases completed consistently with `applicable = false`. +- no CPU fallback was observed. Torch acceptance: -- 15/15 model cases succeeded with `executed_backend = torch`; -- balanced and unbalanced diagnostic cases succeeded; +- 17/17 estimator cases succeeded with `executed_backend = torch`; +- all four Hausman diagnostic cases succeeded; - no silent CPU fallback was observed. +Explicit-constant RandomEffects repair acceptance: + +- `random_effects_explicit_constant_balanced` succeeded on CuPy and Torch; +- `random_effects_explicit_constant_unbalanced` succeeded on CuPy and Torch; +- the largest explicit-constant RE coefficient difference versus NumPy was `2.220446049250313e-16`; +- `random_effects_diagnostic_contract` had zero backend-vs-NumPy difference for every RE case. + +Hausman acceptance: + +- `hausman_balanced`, `hausman_unbalanced`, `hausman_explicit_re_constant_balanced`, and `hausman_explicit_re_constant_unbalanced` all matched NumPy on both GPU backends; +- all generated validation datasets produced a materially indefinite covariance difference, so the test was consistently structured-inapplicable with reason `covariance difference is not positive semidefinite` rather than reporting a fabricated statistic; +- the frontend parser distinguishes standard and RE-explicit-constant Hausman parameterizations so the two cases do not collapse to indistinguishable dashboard variants. + Stage-B checks passed for the maintained model matrix: - parameter-based within/between/overall/adjusted R-squared; - classical model F statistic and p-value where defined; - PooledOLS Breusch-Pagan LM statistic/p-value; - fixed-effects pooling F statistic/p-value; -- FE-vs-RE Hausman applicability/result parity; -- diagnostic covariance matrices. +- FE-vs-RE Hausman applicability/reason parity; +- diagnostic covariance matrices; +- RandomEffects explicit-constant diagnostic metadata. + +Stage-A regression checks also passed for `coef`, `bse`, `tvalues`, `pvalues`, `conf_int`, `nobs`, and `df_resid`. All fields stayed within the runner's `rtol=5e-6`, `atol=5e-7` parity contract; coefficient differences remained at machine-epsilon scale. -Stage-A regression checks also passed for `coef`, `bse`, `tvalues`, `pvalues`, `conf_int`, `nobs`, and `df_resid`. CuPy and Torch results remained within machine-precision-scale differences of the NumPy reference, so the Stage-B integration did not regress the Stage-A coefficient-inference contract. +The canonical frontend source represents 42 validation-only runs: 34 estimator/backend rows plus eight Hausman/backend rows. It deliberately contains no timing or speedup metrics. -The benchmark frontend registers this evidence as 34 validation-only runs: 30 estimator/backend rows plus four Hausman applicability rows. The generated records contain CuPy/Torch backend provenance and validation/inference status but deliberately contain no `metrics.timing` or `metrics.speedup` fields. +The dedicated identity-overhead benchmark remains accepted from the immediately preceding implementation candidate because the `faa95ce7...` repair only changes the explicit-constant RandomEffects auxiliary-within branch, while the benchmark exercises PanelOLS and no-explicit-constant RandomEffects. Its measured digest/no-digest ratios remained approximately 1.04x-1.29x over the maintained target scales. -This record captures the physical acceptance summary supplied for the exact clean implementation head. Subsequent PR commits may update evidence, parser, generated frontend assets, tests, or documentation; the physical numerical result remains applicable only while no Stage-B statistical implementation or physical-runner code changes after the validated implementation head. +This exact-head raw artifact supersedes the earlier `636988...` canonical physical record and the failed `9c78bf66...` correctness attempt. Generated frontend assets and hosted staleness/e2e/production gates must be refreshed after canonical promotion before the stale-evidence review thread is closed. From 7626f24e13d25231720faeb3a0da1f1cc31088ca Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 23:39:09 +0800 Subject: [PATCH 093/165] benchmark: point Panel coverage at final PR122 evidence --- dev/benchmarks/benchmark_coverage_matrix.json | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dev/benchmarks/benchmark_coverage_matrix.json b/dev/benchmarks/benchmark_coverage_matrix.json index 9c54673d2..7788c9bd2 100644 --- a/dev/benchmarks/benchmark_coverage_matrix.json +++ b/dev/benchmarks/benchmark_coverage_matrix.json @@ -86,7 +86,7 @@ "status": "partial_canonical", "source_ids": [ "new-modules-20260624-bcbdb676223b", - "panel-stage-b-pr122-20260808-882892c6e307" + "panel-stage-b-pr122-20260808-b8caffa6f915" ], "representative_dimensions": [ "estimator", @@ -97,7 +97,7 @@ "inference_regression" ], "issue": "#108", - "disposition": "June timing rows cover aligned PanelOLS and RandomEffects. PR #122 adds canonical validation-only CuPy/Torch evidence for six estimators, Stage-B diagnostics, backend provenance, and Stage-A inference regression; broader performance/covariance timing remains open." + "disposition": "June timing rows cover aligned PanelOLS and RandomEffects. PR #122 adds canonical validation-only CuPy/Torch evidence for the 17-case Stage-B estimator matrix, four Hausman parameterizations per backend, backend provenance, and Stage-A inference regression; broader performance/covariance timing remains open." }, { "capability_id": "gam-nonparametric", From 41452f71729c76a75ef9e9be0750ef7513f672da Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 23:40:20 +0800 Subject: [PATCH 094/165] test: update final PR122 frontend coverage contract --- dev/tests/test_frontend_domain_coverage.py | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) diff --git a/dev/tests/test_frontend_domain_coverage.py b/dev/tests/test_frontend_domain_coverage.py index bd7b3949b..ff7808b04 100644 --- a/dev/tests/test_frontend_domain_coverage.py +++ b/dev/tests/test_frontend_domain_coverage.py @@ -303,9 +303,9 @@ def test_panel_stage_b_physical_validation_is_published_without_timing(canonical run for run in output["runs"] if run["source"]["source_id"] - == "panel-stage-b-pr122-20260808-882892c6e307" + == "panel-stage-b-pr122-20260808-b8caffa6f915" ] - assert len(rows) == 34 + assert len(rows) == 42 assert {run["backend"] for run in rows} == {"cupy", "torch"} assert {run["model_id"] for run in rows} == { "PooledOLS", @@ -320,13 +320,17 @@ def test_panel_stage_b_physical_validation_is_published_without_timing(canonical assert all("speedup" not in run["metrics"] for run in rows) assert all( run["parameters"]["measurement_git_sha"] - == "636988751bcbfad3442d24d3073cdfcd2b3ac637" + == "faa95ce7fb5cb204088957fbda5544c20a06fbfc" for run in rows ) hausman = [run for run in rows if run["parameters"].get("diagnostic") == "hausman"] - assert len(hausman) == 4 + assert len(hausman) == 8 assert all(run["parameters"]["applicable"] is False for run in hausman) + assert {run["parameters"]["parameterization"] for run in hausman} == { + "standard", + "re-explicit-constant", + } def test_unsupervised_exposes_complete_source_matrix(canonical_output): @@ -385,8 +389,8 @@ def test_unsupervised_exposes_complete_source_matrix(canonical_output): def test_generated_bundle_has_expected_complete_run_count(canonical_output): output, report, _, _ = canonical_output - assert len(output["runs"]) == 1852 - assert report["runs_generated"] == 1852 + assert len(output["runs"]) == 1860 + assert report["runs_generated"] == 1860 def test_missing_domain_sources_are_manifest_registered(canonical_output): @@ -433,4 +437,4 @@ def test_domain_models_are_present(canonical_output): "WelchANOVA", "TukeyHSD", "BonferroniCorrection", - } <= model_ids + } <= model_ids \ No newline at end of file From 6a0e635243b25245dd527834b9904bafa1853874 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 23:42:31 +0800 Subject: [PATCH 095/165] test: sync PR122 final evidence source ID --- dev/tests/test_benchmark_catalog.py | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/dev/tests/test_benchmark_catalog.py b/dev/tests/test_benchmark_catalog.py index 0ce0e3eda..f16263bad 100644 --- a/dev/tests/test_benchmark_catalog.py +++ b/dev/tests/test_benchmark_catalog.py @@ -84,6 +84,17 @@ def test_catalog_retains_distinct_noncanonical_dispositions(entries): assert focused["provenance_status"] == "validation_evidence" assert focused["issue"] == "#112" + panel_raw = next( + entry for entry in entries + if entry["path"] + == "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json" + ) + assert panel_raw["classification"] == "not_canonical_ready" + assert panel_raw["provenance_status"] == "validation_evidence" + assert panel_raw["timing_protocol_status"] == "not_applicable" + assert panel_raw["statistical_alignment_status"] == "accepted" + assert panel_raw["issue"] == "#93" + def test_coverage_matrix_is_referentially_complete(coverage_matrix, manifest): from dev.benchmarks.frontend_data.catalog import validate_coverage_matrix @@ -99,7 +110,7 @@ def test_coverage_matrix_is_referentially_complete(coverage_matrix, manifest): ] assert rows["panel-estimation"]["source_ids"] == [ "new-modules-20260624-bcbdb676223b", - "panel-stage-b-pr122-20260808-882892c6e307", + "panel-stage-b-pr122-20260808-b8caffa6f915", ] assert rows["distribution-api"]["issue"] == "#101" assert rows["feature-selection-knockoff"]["issue"] == "#103" From 45930715b909b3ab6181ef7f76f8954f3877b948 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 23:43:03 +0800 Subject: [PATCH 096/165] benchmark: classify PR122 raw physical artifact --- dev/benchmarks/benchmark_source_catalog.json | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/dev/benchmarks/benchmark_source_catalog.json b/dev/benchmarks/benchmark_source_catalog.json index 51c162448..b2fdd892c 100644 --- a/dev/benchmarks/benchmark_source_catalog.json +++ b/dev/benchmarks/benchmark_source_catalog.json @@ -131,6 +131,18 @@ "issue": "#112", "reason": "Exact-head P100 focused correctness evidence for PR #116 is retained for audit but is intentionally not a dashboard timing source." }, + { + "rule_id": "pr122-panel-stage-b-physical-validation", + "priority": 20, + "path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "classification": "not_canonical_ready", + "canonical_eligible": false, + "provenance_status": "validation_evidence", + "timing_protocol_status": "not_applicable", + "statistical_alignment_status": "accepted", + "issue": "#93", + "reason": "Exact-head P100 Stage-B correctness/backend-provenance evidence for PR #122 is retained as the immutable raw artifact; its normalized SHA-protected canonical validation-only source is registered separately in frontend_sources.json." + }, { "rule_id": "distribution-current-needs-audit", "priority": 30, From cfac44eefa3f8976b22b8f5dc318761ae34f8301 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 23:45:49 +0800 Subject: [PATCH 097/165] ci: refresh PR122 generated benchmark assets once --- .github/workflows/benchmark-frontend.yml | 43 ++++++++++++++++++++++++ 1 file changed, 43 insertions(+) diff --git a/.github/workflows/benchmark-frontend.yml b/.github/workflows/benchmark-frontend.yml index 683318920..edef30f73 100644 --- a/.github/workflows/benchmark-frontend.yml +++ b/.github/workflows/benchmark-frontend.yml @@ -39,6 +39,9 @@ on: - 'results/benchmark_frontend_sources/**' - 'pyproject.toml' +permissions: + contents: write + concurrency: group: benchmark-frontend-${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }} cancel-in-progress: true @@ -180,3 +183,43 @@ jobs: name: playwright-production-report path: frontend/playwright-report/ retention-days: 30 + + refresh-generated-assets: + if: >- + github.event_name == 'pull_request' && + github.event.pull_request.head.repo.full_name == github.repository && + github.event.pull_request.head.ref == 'agent/panel-p1-stage-b-diagnostics' + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + ref: ${{ github.event.pull_request.head.ref }} + - uses: actions/setup-python@v5 + with: + python-version: '3.11' + - name: Install schema validation dependency + run: python -m pip install 'jsonschema[format]' + - uses: actions/setup-node@v4 + with: + node-version: '20' + - name: Refresh deterministic benchmark assets + run: | + python dev/benchmarks/generate_benchmark_data.py \ + --out frontend/public/data/benchmark_data.json \ + --report frontend/public/data/parse_report.json \ + --inventory-out frontend/public/data/source_inventory.json \ + --deterministic --strict-sources + cd frontend + npm ci + npm run build + - name: Commit refreshed generated assets + run: | + git config user.name 'github-actions[bot]' + git config user.email '41898282+github-actions[bot]@users.noreply.github.com' + git add frontend/public/data docs/assets/benchmarks + if git diff --cached --quiet; then + echo 'Generated assets already current.' + exit 0 + fi + git commit -m 'chore: refresh PR122 benchmark frontend assets' + git push origin HEAD:${{ github.event.pull_request.head.ref }} From fb68bc50483adc6a3e82696d019fb625ffb5087d Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Sat, 8 Aug 2026 15:46:24 +0000 Subject: [PATCH 098/165] chore: refresh PR122 benchmark frontend assets --- .../benchmarks/data/benchmark_data.json | 892 ++++++++++++++---- docs/assets/benchmarks/data/parse_report.json | 4 +- .../benchmarks/data/source_inventory.json | 34 +- frontend/public/data/benchmark_data.json | 892 ++++++++++++++---- frontend/public/data/parse_report.json | 4 +- frontend/public/data/source_inventory.json | 34 +- 6 files changed, 1496 insertions(+), 364 deletions(-) diff --git a/docs/assets/benchmarks/data/benchmark_data.json b/docs/assets/benchmarks/data/benchmark_data.json index be30d0b1a..54d292368 100644 --- a/docs/assets/benchmarks/data/benchmark_data.json +++ b/docs/assets/benchmarks/data/benchmark_data.json @@ -4,7 +4,7 @@ "meta": { "generator": "dev/benchmarks/generate_benchmark_data.py", "git_sha": "deterministic", - "generation_id": "820a294b2b6fd58f6c1384b5ffad602f20168dc30102f93a49895e97fb0003dc" + "generation_id": "45a94e710ad14d391e40efb258f904369f3625a55d2b3080f635d98e3677609f" }, "environments": [ { @@ -31,7 +31,7 @@ { "env_id": "remote-p100-pr122-20260808", "label": "Tesla P100 PR #122 Panel Stage B validation — 2026-08-08", - "gpu": "Tesla P100", + "gpu": "Tesla P100-SXM2-16GB", "cpu": "x86_64" } ], @@ -91462,7 +91462,7 @@ "comparison_id": "cv-benchmark-pr116-20260807" }, { - "run_id": "5462e1e90a36cd55", + "run_id": "8a71ce77d803ed74", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -91486,7 +91486,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -91494,9 +91494,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -91535,7 +91535,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "363b731718b94e5c", + "run_id": "0d85b9dd44963867", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -91559,7 +91559,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -91567,9 +91567,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -91612,7 +91612,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "9b5cd2eed291b06a", + "run_id": "d931273510d98478", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -91636,7 +91636,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -91644,9 +91644,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -91681,7 +91681,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "3c891541f7e11fe9", + "run_id": "1b776255eaf957b9", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -91705,7 +91705,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -91713,9 +91713,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -91750,7 +91750,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "f3c1ac064c1fd7a8", + "run_id": "c7dc0b9be6ea7fae", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -91774,7 +91774,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -91782,9 +91782,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -91823,7 +91823,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "8e3629fb1eac1330", + "run_id": "b38fec0f44a85cbd", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -91847,7 +91847,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -91855,9 +91855,82 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "random_effects_diagnostic_contract", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "1509019810790eb8", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-376492aadf7db27e", + "method_config_id": "method-af8a0d67f1b0b4e8", + "variant": "explicit-constant-balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n54_p3", + "n_samples": 54, + "n_features": 3, + "label": "54×3" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -91875,6 +91948,10 @@ "metric": "stage_a_inference", "status": "pass" }, + { + "metric": "random_effects_diagnostic_contract", + "status": "pass" + }, { "metric": "backend_provenance", "status": "pass" @@ -91892,7 +91969,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "a86430078e2ff148", + "run_id": "6fe71f02057dde61", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -91916,7 +91993,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -91924,9 +92001,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -91961,7 +92038,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "fe5e2dade2f86161", + "run_id": "acefbc894ee85927", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -91985,7 +92062,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -91993,9 +92070,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -92034,7 +92111,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "5444a2583a7c811d", + "run_id": "dd74a3741c06baf1", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -92058,7 +92135,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -92066,9 +92143,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -92107,7 +92184,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "7795cf3edbbd1477", + "run_id": "4d70cd27967389a5", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -92131,7 +92208,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -92139,9 +92216,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -92184,7 +92261,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "cb549b4cee7bbbc6", + "run_id": "f32ab8cd8e2aeedd", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -92208,7 +92285,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -92216,9 +92293,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -92253,7 +92330,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "ad5287f3107212e9", + "run_id": "3d1c833e7d401aef", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -92277,7 +92354,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -92285,9 +92362,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -92322,7 +92399,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "3741822acd5fa940", + "run_id": "660320ec96ec4e4e", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -92346,7 +92423,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -92354,9 +92431,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -92395,7 +92472,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "049f251d8724aeba", + "run_id": "ff70c785429660ae", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -92419,7 +92496,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -92427,9 +92504,82 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "random_effects_diagnostic_contract", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "b96058e6fa248bf3", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-9a06cd1ab60b638f", + "method_config_id": "method-b230d1629d626033", + "variant": "explicit-constant-unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n49_p3", + "n_samples": 49, + "n_features": 3, + "label": "49×3" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -92447,6 +92597,10 @@ "metric": "stage_a_inference", "status": "pass" }, + { + "metric": "random_effects_diagnostic_contract", + "status": "pass" + }, { "metric": "backend_provenance", "status": "pass" @@ -92464,7 +92618,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "fbec840dfb634ea5", + "run_id": "1b41ab9b767771d1", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -92488,7 +92642,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -92496,9 +92650,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -92533,7 +92687,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "c648efed4b988c77", + "run_id": "9447826107945e33", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -92558,8 +92712,9 @@ "parameters": { "metric_scope": "physical_validation", "diagnostic": "hausman", + "parameterization": "standard", "applicable": false, - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -92567,9 +92722,68 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "hausman_backend_consistency", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "32e34d5c96930300", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-c1327c75008f9dfa", + "method_config_id": "method-6352b566ecc4def7", + "variant": "hausman-re-explicit-constant-balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "diagnostic": "hausman", + "parameterization": "re-explicit-constant", + "applicable": false, + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -92591,7 +92805,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "764fee13f2e956df", + "run_id": "9e2b8c30b55698ab", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -92616,8 +92830,9 @@ "parameters": { "metric_scope": "physical_validation", "diagnostic": "hausman", + "parameterization": "standard", "applicable": false, - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -92625,9 +92840,68 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "hausman_backend_consistency", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "29bbe1904400dd6a", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-7053bf05f9fc593f", + "method_config_id": "method-b49c53698837f046", + "variant": "hausman-re-explicit-constant-unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "diagnostic": "hausman", + "parameterization": "re-explicit-constant", + "applicable": false, + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -92649,7 +92923,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "24514a1e0d50d1c1", + "run_id": "218fb4a5eb609091", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -92673,7 +92947,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -92681,9 +92955,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -92722,7 +92996,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "54ea0b78a1cb2b3d", + "run_id": "9adb6ddf275cfc14", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -92746,7 +93020,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -92754,9 +93028,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -92799,7 +93073,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "67926bc17240c2e7", + "run_id": "8bab7ca73de7592f", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -92823,7 +93097,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -92831,9 +93105,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -92868,7 +93142,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "4e4c70589919b97c", + "run_id": "12cf689cd1b21c9d", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -92892,7 +93166,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -92900,9 +93174,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -92937,7 +93211,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "08affb4e86d9815a", + "run_id": "a04f5cb6744c1448", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -92961,7 +93235,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -92969,9 +93243,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -93010,7 +93284,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "fd8c622bab6bd110", + "run_id": "da8bd2f714ec4f41", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -93034,7 +93308,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -93042,9 +93316,82 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "random_effects_diagnostic_contract", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "980b1ea5069ec20f", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-376492aadf7db27e", + "method_config_id": "method-af8a0d67f1b0b4e8", + "variant": "explicit-constant-balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n54_p3", + "n_samples": 54, + "n_features": 3, + "label": "54×3" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -93062,6 +93409,10 @@ "metric": "stage_a_inference", "status": "pass" }, + { + "metric": "random_effects_diagnostic_contract", + "status": "pass" + }, { "metric": "backend_provenance", "status": "pass" @@ -93079,7 +93430,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "99edb39a954890dc", + "run_id": "0f98b0640c2e6b1a", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -93103,7 +93454,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -93111,9 +93462,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -93148,7 +93499,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "5250e9b9de8ef523", + "run_id": "67063d8328552d8e", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -93172,7 +93523,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -93180,9 +93531,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -93221,7 +93572,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "05d209eec2dffe87", + "run_id": "2a6e0490de299456", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -93245,7 +93596,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -93253,9 +93604,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -93294,7 +93645,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "8da271bbeb535d97", + "run_id": "3102e0981defbfcc", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -93318,7 +93669,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -93326,9 +93677,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -93371,7 +93722,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "52f52d41c9e144f8", + "run_id": "8b95ddb25cf6a2b2", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -93395,7 +93746,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -93403,9 +93754,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -93440,7 +93791,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "9d6e94f4096afe8b", + "run_id": "a5b35d639e6ed1cd", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -93464,7 +93815,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -93472,9 +93823,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -93509,7 +93860,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "0b6773a279743351", + "run_id": "ae4e242f094f74e0", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -93533,7 +93884,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -93541,9 +93892,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -93582,7 +93933,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "ae7f621572590cec", + "run_id": "bdc905873c71e5e7", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -93606,7 +93957,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -93614,9 +93965,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -93634,6 +93985,10 @@ "metric": "stage_a_inference", "status": "pass" }, + { + "metric": "random_effects_diagnostic_contract", + "status": "pass" + }, { "metric": "backend_provenance", "status": "pass" @@ -93651,7 +94006,80 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "dfe4a583f9b1ef12", + "run_id": "38b24f285a69e581", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-9a06cd1ab60b638f", + "method_config_id": "method-b230d1629d626033", + "variant": "explicit-constant-unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n49_p3", + "n_samples": 49, + "n_features": 3, + "label": "49×3" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "random_effects_diagnostic_contract", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "ad5190138d1f4299", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -93675,7 +94103,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -93683,9 +94111,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -93720,7 +94148,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "0a93708869246e19", + "run_id": "e81dfb4f8062f65e", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -93745,8 +94173,9 @@ "parameters": { "metric_scope": "physical_validation", "diagnostic": "hausman", + "parameterization": "standard", "applicable": false, - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -93754,9 +94183,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -93778,7 +94207,66 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "e20ff6c81af91947", + "run_id": "85f69cd996ebbdab", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-c1327c75008f9dfa", + "method_config_id": "method-6352b566ecc4def7", + "variant": "hausman-re-explicit-constant-balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "diagnostic": "hausman", + "parameterization": "re-explicit-constant", + "applicable": false, + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "hausman_backend_consistency", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "76d711ed53a9060e", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -93803,8 +94291,9 @@ "parameters": { "metric_scope": "physical_validation", "diagnostic": "hausman", + "parameterization": "standard", "applicable": false, - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -93812,9 +94301,68 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "hausman_backend_consistency", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "261d8f1d1a18f873", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-7053bf05f9fc593f", + "method_config_id": "method-b49c53698837f046", + "variant": "hausman-re-explicit-constant-unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "diagnostic": "hausman", + "parameterization": "re-explicit-constant", + "applicable": false, + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { diff --git a/docs/assets/benchmarks/data/parse_report.json b/docs/assets/benchmarks/data/parse_report.json index af05c2ebc..e00d2611c 100644 --- a/docs/assets/benchmarks/data/parse_report.json +++ b/docs/assets/benchmarks/data/parse_report.json @@ -3,8 +3,8 @@ "files_seen": 11, "files_parsed": 11, "files_skipped": 0, - "runs_generated": 1852, - "generation_id": "820a294b2b6fd58f6c1384b5ffad602f20168dc30102f93a49895e97fb0003dc", + "runs_generated": 1860, + "generation_id": "45a94e710ad14d391e40efb258f904369f3625a55d2b3080f635d98e3677609f", "issues": [ { "source_id": "glm-solver-20260623-1b6197d94d88", diff --git a/docs/assets/benchmarks/data/source_inventory.json b/docs/assets/benchmarks/data/source_inventory.json index 322080ace..518d3484f 100644 --- a/docs/assets/benchmarks/data/source_inventory.json +++ b/docs/assets/benchmarks/data/source_inventory.json @@ -1,22 +1,22 @@ { "inventory_version": "2.0", "catalog_version": "2.0", - "catalog_digest": "013c057dfd3e9f8bd4fe529e6b843be2851461b65d215222fa6085aacdbfc049", + "catalog_digest": "ddb41b31459bcfb1ebbd0efc20dbf1f5a747ba326b071f16fa171270ecf28717", "coverage_matrix_version": "1.0", - "coverage_matrix_digest": "2fdfa2291fac57c59cb0ec75669380fbfd278b995556b3b18043f7a4e2624360", - "discovered_json_artifacts": 90, - "classified_candidate_sources": 90, + "coverage_matrix_digest": "4b5f60ff535d819979d8d9e11f5c41ad6f4f3f8bb3405abdffcc03856a923113", + "discovered_json_artifacts": 91, + "classified_candidate_sources": 91, "eligible_sources": 11, "registered_sources": 11, "available_registered_sources": 11, "parsed_registered_sources": 11, "eligible_unregistered_sources": 0, - "not_canonical_ready_sources": 42, + "not_canonical_ready_sources": 43, "historical_or_excluded_sources": 37, "superseded_or_duplicate_sources": 9, "unrelated_json_artifacts": 0, "unclassified_artifacts": 0, - "catalog_policy_digest": "23cd0e6e1ccc7a563a42fd6d999a7f6f0a3590726f93030c41c95672ebe19e0a", + "catalog_policy_digest": "a6c275db00cdc4819a443117eef58e0f8eff7c04b923721371ba4b1bdb713195", "catalog_entries": [ { "path": "results/bench_large_scale.json", @@ -835,7 +835,7 @@ "classification": "registered_canonical", "canonical_eligible": true, "registered": true, - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", "parser": "panel_stage_b_physical_validation", "parser_version": "1.0", "provenance_status": "complete", @@ -1242,6 +1242,24 @@ "issue": "#112", "rule_id": "pr116-logistic-cv-focused-validation" }, + { + "path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "artifact_type": "json", + "source_date": null, + "classification": "not_canonical_ready", + "canonical_eligible": false, + "registered": false, + "source_id": null, + "parser": null, + "parser_version": null, + "provenance_status": "validation_evidence", + "timing_protocol_status": "not_applicable", + "statistical_alignment_status": "accepted", + "reason": "Exact-head P100 Stage-B correctness/backend-provenance evidence for PR #122 is retained as the immutable raw artifact; its normalized SHA-protected canonical validation-only source is registered separately in frontend_sources.json.", + "superseded_by": null, + "issue": "#93", + "rule_id": "pr122-panel-stage-b-physical-validation" + }, { "path": "results/pr74_inference_validation.json", "artifact_type": "json", @@ -1645,5 +1663,5 @@ "current_evidence_not_canonical_ready": 2, "partial_canonical": 7 }, - "generation_id": "820a294b2b6fd58f6c1384b5ffad602f20168dc30102f93a49895e97fb0003dc" + "generation_id": "45a94e710ad14d391e40efb258f904369f3625a55d2b3080f635d98e3677609f" } \ No newline at end of file diff --git a/frontend/public/data/benchmark_data.json b/frontend/public/data/benchmark_data.json index be30d0b1a..54d292368 100644 --- a/frontend/public/data/benchmark_data.json +++ b/frontend/public/data/benchmark_data.json @@ -4,7 +4,7 @@ "meta": { "generator": "dev/benchmarks/generate_benchmark_data.py", "git_sha": "deterministic", - "generation_id": "820a294b2b6fd58f6c1384b5ffad602f20168dc30102f93a49895e97fb0003dc" + "generation_id": "45a94e710ad14d391e40efb258f904369f3625a55d2b3080f635d98e3677609f" }, "environments": [ { @@ -31,7 +31,7 @@ { "env_id": "remote-p100-pr122-20260808", "label": "Tesla P100 PR #122 Panel Stage B validation — 2026-08-08", - "gpu": "Tesla P100", + "gpu": "Tesla P100-SXM2-16GB", "cpu": "x86_64" } ], @@ -91462,7 +91462,7 @@ "comparison_id": "cv-benchmark-pr116-20260807" }, { - "run_id": "5462e1e90a36cd55", + "run_id": "8a71ce77d803ed74", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -91486,7 +91486,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -91494,9 +91494,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -91535,7 +91535,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "363b731718b94e5c", + "run_id": "0d85b9dd44963867", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -91559,7 +91559,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -91567,9 +91567,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -91612,7 +91612,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "9b5cd2eed291b06a", + "run_id": "d931273510d98478", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -91636,7 +91636,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -91644,9 +91644,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -91681,7 +91681,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "3c891541f7e11fe9", + "run_id": "1b776255eaf957b9", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -91705,7 +91705,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -91713,9 +91713,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -91750,7 +91750,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "f3c1ac064c1fd7a8", + "run_id": "c7dc0b9be6ea7fae", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -91774,7 +91774,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -91782,9 +91782,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -91823,7 +91823,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "8e3629fb1eac1330", + "run_id": "b38fec0f44a85cbd", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -91847,7 +91847,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -91855,9 +91855,82 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "random_effects_diagnostic_contract", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "1509019810790eb8", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-376492aadf7db27e", + "method_config_id": "method-af8a0d67f1b0b4e8", + "variant": "explicit-constant-balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n54_p3", + "n_samples": 54, + "n_features": 3, + "label": "54×3" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -91875,6 +91948,10 @@ "metric": "stage_a_inference", "status": "pass" }, + { + "metric": "random_effects_diagnostic_contract", + "status": "pass" + }, { "metric": "backend_provenance", "status": "pass" @@ -91892,7 +91969,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "a86430078e2ff148", + "run_id": "6fe71f02057dde61", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -91916,7 +91993,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -91924,9 +92001,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -91961,7 +92038,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "fe5e2dade2f86161", + "run_id": "acefbc894ee85927", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -91985,7 +92062,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -91993,9 +92070,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -92034,7 +92111,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "5444a2583a7c811d", + "run_id": "dd74a3741c06baf1", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -92058,7 +92135,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -92066,9 +92143,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -92107,7 +92184,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "7795cf3edbbd1477", + "run_id": "4d70cd27967389a5", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -92131,7 +92208,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -92139,9 +92216,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -92184,7 +92261,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "cb549b4cee7bbbc6", + "run_id": "f32ab8cd8e2aeedd", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -92208,7 +92285,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -92216,9 +92293,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -92253,7 +92330,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "ad5287f3107212e9", + "run_id": "3d1c833e7d401aef", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -92277,7 +92354,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -92285,9 +92362,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -92322,7 +92399,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "3741822acd5fa940", + "run_id": "660320ec96ec4e4e", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -92346,7 +92423,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -92354,9 +92431,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -92395,7 +92472,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "049f251d8724aeba", + "run_id": "ff70c785429660ae", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -92419,7 +92496,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -92427,9 +92504,82 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "random_effects_diagnostic_contract", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "b96058e6fa248bf3", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-9a06cd1ab60b638f", + "method_config_id": "method-b230d1629d626033", + "variant": "explicit-constant-unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n49_p3", + "n_samples": 49, + "n_features": 3, + "label": "49×3" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -92447,6 +92597,10 @@ "metric": "stage_a_inference", "status": "pass" }, + { + "metric": "random_effects_diagnostic_contract", + "status": "pass" + }, { "metric": "backend_provenance", "status": "pass" @@ -92464,7 +92618,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "fbec840dfb634ea5", + "run_id": "1b41ab9b767771d1", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -92488,7 +92642,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -92496,9 +92650,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -92533,7 +92687,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "c648efed4b988c77", + "run_id": "9447826107945e33", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -92558,8 +92712,9 @@ "parameters": { "metric_scope": "physical_validation", "diagnostic": "hausman", + "parameterization": "standard", "applicable": false, - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -92567,9 +92722,68 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "hausman_backend_consistency", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "32e34d5c96930300", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-c1327c75008f9dfa", + "method_config_id": "method-6352b566ecc4def7", + "variant": "hausman-re-explicit-constant-balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "diagnostic": "hausman", + "parameterization": "re-explicit-constant", + "applicable": false, + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -92591,7 +92805,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "764fee13f2e956df", + "run_id": "9e2b8c30b55698ab", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -92616,8 +92830,9 @@ "parameters": { "metric_scope": "physical_validation", "diagnostic": "hausman", + "parameterization": "standard", "applicable": false, - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -92625,9 +92840,68 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "hausman_backend_consistency", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "29bbe1904400dd6a", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-7053bf05f9fc593f", + "method_config_id": "method-b49c53698837f046", + "variant": "hausman-re-explicit-constant-unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "diagnostic": "hausman", + "parameterization": "re-explicit-constant", + "applicable": false, + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -92649,7 +92923,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "24514a1e0d50d1c1", + "run_id": "218fb4a5eb609091", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -92673,7 +92947,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -92681,9 +92955,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -92722,7 +92996,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "54ea0b78a1cb2b3d", + "run_id": "9adb6ddf275cfc14", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -92746,7 +93020,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -92754,9 +93028,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -92799,7 +93073,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "67926bc17240c2e7", + "run_id": "8bab7ca73de7592f", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -92823,7 +93097,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -92831,9 +93105,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -92868,7 +93142,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "4e4c70589919b97c", + "run_id": "12cf689cd1b21c9d", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -92892,7 +93166,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -92900,9 +93174,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -92937,7 +93211,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "08affb4e86d9815a", + "run_id": "a04f5cb6744c1448", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -92961,7 +93235,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -92969,9 +93243,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -93010,7 +93284,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "fd8c622bab6bd110", + "run_id": "da8bd2f714ec4f41", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -93034,7 +93308,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -93042,9 +93316,82 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "random_effects_diagnostic_contract", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "980b1ea5069ec20f", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-376492aadf7db27e", + "method_config_id": "method-af8a0d67f1b0b4e8", + "variant": "explicit-constant-balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n54_p3", + "n_samples": 54, + "n_features": 3, + "label": "54×3" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -93062,6 +93409,10 @@ "metric": "stage_a_inference", "status": "pass" }, + { + "metric": "random_effects_diagnostic_contract", + "status": "pass" + }, { "metric": "backend_provenance", "status": "pass" @@ -93079,7 +93430,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "99edb39a954890dc", + "run_id": "0f98b0640c2e6b1a", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -93103,7 +93454,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -93111,9 +93462,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -93148,7 +93499,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "5250e9b9de8ef523", + "run_id": "67063d8328552d8e", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -93172,7 +93523,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -93180,9 +93531,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -93221,7 +93572,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "05d209eec2dffe87", + "run_id": "2a6e0490de299456", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -93245,7 +93596,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -93253,9 +93604,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -93294,7 +93645,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "8da271bbeb535d97", + "run_id": "3102e0981defbfcc", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -93318,7 +93669,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -93326,9 +93677,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -93371,7 +93722,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "52f52d41c9e144f8", + "run_id": "8b95ddb25cf6a2b2", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -93395,7 +93746,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -93403,9 +93754,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -93440,7 +93791,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "9d6e94f4096afe8b", + "run_id": "a5b35d639e6ed1cd", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -93464,7 +93815,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -93472,9 +93823,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -93509,7 +93860,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "0b6773a279743351", + "run_id": "ae4e242f094f74e0", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -93533,7 +93884,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -93541,9 +93892,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -93582,7 +93933,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "ae7f621572590cec", + "run_id": "bdc905873c71e5e7", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -93606,7 +93957,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -93614,9 +93965,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -93634,6 +93985,10 @@ "metric": "stage_a_inference", "status": "pass" }, + { + "metric": "random_effects_diagnostic_contract", + "status": "pass" + }, { "metric": "backend_provenance", "status": "pass" @@ -93651,7 +94006,80 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "dfe4a583f9b1ef12", + "run_id": "38b24f285a69e581", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-9a06cd1ab60b638f", + "method_config_id": "method-b230d1629d626033", + "variant": "explicit-constant-unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n49_p3", + "n_samples": 49, + "n_features": 3, + "label": "49×3" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "fit_statistics", + "status": "pass" + }, + { + "metric": "diagnostic_covariance", + "status": "pass" + }, + { + "metric": "stage_a_inference", + "status": "pass" + }, + { + "metric": "random_effects_diagnostic_contract", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "ad5190138d1f4299", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -93675,7 +94103,7 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -93683,9 +94111,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -93720,7 +94148,7 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "0a93708869246e19", + "run_id": "e81dfb4f8062f65e", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -93745,8 +94173,9 @@ "parameters": { "metric_scope": "physical_validation", "diagnostic": "hausman", + "parameterization": "standard", "applicable": false, - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -93754,9 +94183,9 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { @@ -93778,7 +94207,66 @@ "comparison_id": "panel-stage-b-pr122-20260808" }, { - "run_id": "e20ff6c81af91947", + "run_id": "85f69cd996ebbdab", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-c1327c75008f9dfa", + "method_config_id": "method-6352b566ecc4def7", + "variant": "hausman-re-explicit-constant-balanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n54_p2", + "n_samples": 54, + "n_features": 2, + "label": "54×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "diagnostic": "hausman", + "parameterization": "re-explicit-constant", + "applicable": false, + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "hausman_backend_consistency", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "76d711ed53a9060e", "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260808", "category_ids": [ @@ -93803,8 +94291,9 @@ "parameters": { "metric_scope": "physical_validation", "diagnostic": "hausman", + "parameterization": "standard", "applicable": false, - "measurement_git_sha": "636988751bcbfad3442d24d3073cdfcd2b3ac637", + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", "working_tree_clean": true }, "source": { @@ -93812,9 +94301,68 @@ "date": "2026-08-08", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", - "original_path": "", - "sha256": "882892c6e3077fe3b9f6084212647311da795fd05d1ed9f12ec53da1e05d0d4d" + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "hausman_backend_consistency", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260808.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260808" + }, + { + "run_id": "261d8f1d1a18f873", + "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260808", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-7053bf05f9fc593f", + "method_config_id": "method-b49c53698837f046", + "variant": "hausman-re-explicit-constant-unbalanced", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n49_p2", + "n_samples": 49, + "n_features": 2, + "label": "49×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "diagnostic": "hausman", + "parameterization": "re-explicit-constant", + "applicable": false, + "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260808.json", + "date": "2026-08-08", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" }, "metrics": { "validation": { diff --git a/frontend/public/data/parse_report.json b/frontend/public/data/parse_report.json index af05c2ebc..e00d2611c 100644 --- a/frontend/public/data/parse_report.json +++ b/frontend/public/data/parse_report.json @@ -3,8 +3,8 @@ "files_seen": 11, "files_parsed": 11, "files_skipped": 0, - "runs_generated": 1852, - "generation_id": "820a294b2b6fd58f6c1384b5ffad602f20168dc30102f93a49895e97fb0003dc", + "runs_generated": 1860, + "generation_id": "45a94e710ad14d391e40efb258f904369f3625a55d2b3080f635d98e3677609f", "issues": [ { "source_id": "glm-solver-20260623-1b6197d94d88", diff --git a/frontend/public/data/source_inventory.json b/frontend/public/data/source_inventory.json index 322080ace..518d3484f 100644 --- a/frontend/public/data/source_inventory.json +++ b/frontend/public/data/source_inventory.json @@ -1,22 +1,22 @@ { "inventory_version": "2.0", "catalog_version": "2.0", - "catalog_digest": "013c057dfd3e9f8bd4fe529e6b843be2851461b65d215222fa6085aacdbfc049", + "catalog_digest": "ddb41b31459bcfb1ebbd0efc20dbf1f5a747ba326b071f16fa171270ecf28717", "coverage_matrix_version": "1.0", - "coverage_matrix_digest": "2fdfa2291fac57c59cb0ec75669380fbfd278b995556b3b18043f7a4e2624360", - "discovered_json_artifacts": 90, - "classified_candidate_sources": 90, + "coverage_matrix_digest": "4b5f60ff535d819979d8d9e11f5c41ad6f4f3f8bb3405abdffcc03856a923113", + "discovered_json_artifacts": 91, + "classified_candidate_sources": 91, "eligible_sources": 11, "registered_sources": 11, "available_registered_sources": 11, "parsed_registered_sources": 11, "eligible_unregistered_sources": 0, - "not_canonical_ready_sources": 42, + "not_canonical_ready_sources": 43, "historical_or_excluded_sources": 37, "superseded_or_duplicate_sources": 9, "unrelated_json_artifacts": 0, "unclassified_artifacts": 0, - "catalog_policy_digest": "23cd0e6e1ccc7a563a42fd6d999a7f6f0a3590726f93030c41c95672ebe19e0a", + "catalog_policy_digest": "a6c275db00cdc4819a443117eef58e0f8eff7c04b923721371ba4b1bdb713195", "catalog_entries": [ { "path": "results/bench_large_scale.json", @@ -835,7 +835,7 @@ "classification": "registered_canonical", "canonical_eligible": true, "registered": true, - "source_id": "panel-stage-b-pr122-20260808-882892c6e307", + "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", "parser": "panel_stage_b_physical_validation", "parser_version": "1.0", "provenance_status": "complete", @@ -1242,6 +1242,24 @@ "issue": "#112", "rule_id": "pr116-logistic-cv-focused-validation" }, + { + "path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", + "artifact_type": "json", + "source_date": null, + "classification": "not_canonical_ready", + "canonical_eligible": false, + "registered": false, + "source_id": null, + "parser": null, + "parser_version": null, + "provenance_status": "validation_evidence", + "timing_protocol_status": "not_applicable", + "statistical_alignment_status": "accepted", + "reason": "Exact-head P100 Stage-B correctness/backend-provenance evidence for PR #122 is retained as the immutable raw artifact; its normalized SHA-protected canonical validation-only source is registered separately in frontend_sources.json.", + "superseded_by": null, + "issue": "#93", + "rule_id": "pr122-panel-stage-b-physical-validation" + }, { "path": "results/pr74_inference_validation.json", "artifact_type": "json", @@ -1645,5 +1663,5 @@ "current_evidence_not_canonical_ready": 2, "partial_canonical": 7 }, - "generation_id": "820a294b2b6fd58f6c1384b5ffad602f20168dc30102f93a49895e97fb0003dc" + "generation_id": "45a94e710ad14d391e40efb258f904369f3625a55d2b3080f635d98e3677609f" } \ No newline at end of file From 9ac1257a03453e96546bdbd1531a2760a7d1593a Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 23:46:57 +0800 Subject: [PATCH 099/165] ci: restore read-only benchmark frontend workflow --- .github/workflows/benchmark-frontend.yml | 43 ------------------------ 1 file changed, 43 deletions(-) diff --git a/.github/workflows/benchmark-frontend.yml b/.github/workflows/benchmark-frontend.yml index edef30f73..683318920 100644 --- a/.github/workflows/benchmark-frontend.yml +++ b/.github/workflows/benchmark-frontend.yml @@ -39,9 +39,6 @@ on: - 'results/benchmark_frontend_sources/**' - 'pyproject.toml' -permissions: - contents: write - concurrency: group: benchmark-frontend-${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }} cancel-in-progress: true @@ -183,43 +180,3 @@ jobs: name: playwright-production-report path: frontend/playwright-report/ retention-days: 30 - - refresh-generated-assets: - if: >- - github.event_name == 'pull_request' && - github.event.pull_request.head.repo.full_name == github.repository && - github.event.pull_request.head.ref == 'agent/panel-p1-stage-b-diagnostics' - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v4 - with: - ref: ${{ github.event.pull_request.head.ref }} - - uses: actions/setup-python@v5 - with: - python-version: '3.11' - - name: Install schema validation dependency - run: python -m pip install 'jsonschema[format]' - - uses: actions/setup-node@v4 - with: - node-version: '20' - - name: Refresh deterministic benchmark assets - run: | - python dev/benchmarks/generate_benchmark_data.py \ - --out frontend/public/data/benchmark_data.json \ - --report frontend/public/data/parse_report.json \ - --inventory-out frontend/public/data/source_inventory.json \ - --deterministic --strict-sources - cd frontend - npm ci - npm run build - - name: Commit refreshed generated assets - run: | - git config user.name 'github-actions[bot]' - git config user.email '41898282+github-actions[bot]@users.noreply.github.com' - git add frontend/public/data docs/assets/benchmarks - if git diff --cached --quiet; then - echo 'Generated assets already current.' - exit 0 - fi - git commit -m 'chore: refresh PR122 benchmark frontend assets' - git push origin HEAD:${{ github.event.pull_request.head.ref }} From 9113ac303c249ba0148a538136e81b6b636aa0b2 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 23:48:37 +0800 Subject: [PATCH 100/165] docs: publish final PR122 physical evidence --- docs/en/changelog.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/docs/en/changelog.md b/docs/en/changelog.md index 816ca276e..9e1553091 100644 --- a/docs/en/changelog.md +++ b/docs/en/changelog.md @@ -14,7 +14,8 @@ - Added the classical pooling F test for fixed effects, the one-way entity error-components Breusch-Pagan LM test including the Baltagi-Li unbalanced-panel formula, and the classical one-way entity FE-vs-RE Hausman test. Inapplicable econometric cases return structured reasons; singular positive-semidefinite Hausman covariance differences use a documented generalized-inverse/rank extension, while materially indefinite differences are rejected. - Added optional `entity_ids` to `PooledOLS.fit()` and `FamaMacBeth.fit()` solely for Stage-B within/between fit statistics and the panel BP-LM path. Pooled HAC sorting now carries entity diagnostic metadata through the same stable permutation as X/y. Formula missing-row filtering aligns observation-level side arrays before diagnostics are formed. - Added analytic/fitted regressions, maintained Python 3.9 + Torch 2.0 CPU parity, and an executable `linearmodels==7.0` definition-alignment job. FirstDifference external comparison is restricted to panels where both implementations use the same transformed sample; Stage B does not silently redefine the Stage-A adjacent-observed-row differencing contract for internal time gaps. -- Added `dev/benchmarks/validate_panel_stage_b_gpu.py` as the final exact-head physical correctness/provenance gate. The schema-2 runner compares NumPy against requested CuPy/Torch CUDA for Stage-B diagnostics and fit statistics and rechecks `coef`, BSE, t-values, p-values, confidence intervals, `nobs`, and `df_resid` so the new diagnostic integration cannot mask a Stage-A inference regression. Physical validation passed on exact clean implementation head `636988751bcbfad3442d24d3073cdfcd2b3ac637` using Tesla P100, Python 3.9.16, CuPy 13.6.0, and PyTorch 2.0.0: all 15 CuPy and 15 Torch model cases plus balanced/unbalanced diagnostics succeeded with no CPU fallback, and the Stage-A inference regressions remained within machine-precision-scale differences of NumPy. +- Added `dev/benchmarks/validate_panel_stage_b_gpu.py` as the exact-head physical correctness/provenance gate. The final schema-2 run passed on clean implementation head `faa95ce7fb5cb204088957fbda5544c20a06fbfc` using Tesla P100-SXM2-16GB and Python 3.9.16: CuPy and Torch CUDA each passed all 17 estimator cases and all four Hausman diagnostics with no CPU fallback. The largest explicit-constant RandomEffects coefficient difference from NumPy was `2.22e-16`, and the RandomEffects diagnostic contract matched NumPy exactly. The raw metadata reports PyTorch 2.0.0; its CuPy package-version lookup is unavailable (`null`), so no CuPy version is inferred from an earlier run. +- Promoted the exact-head raw artifact `results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json` (SHA-256 `c1ba014a3b9bb0d32cbc0ca3d844ccfe767e7149189efb9ba2969f5bc1b94b31`) into the SHA-protected canonical validation-only frontend source. The dashboard now publishes 42 Stage-B validation rows—34 estimator/backend rows plus eight Hausman/backend rows—without fabricating timing or speedup fields, and distinguishes the standard versus RE-explicit-constant Hausman parameterizations. Related: Issue #93 and pull request #122. From f7da4d54b5ff07b4deabb06479f9efefea441297 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sat, 8 Aug 2026 23:49:20 +0800 Subject: [PATCH 101/165] =?UTF-8?q?docs:=20=E5=90=8C=E6=AD=A5=20PR122=20?= =?UTF-8?q?=E6=9C=80=E7=BB=88=E7=89=A9=E7=90=86=E9=AA=8C=E8=AF=81=E8=AF=81?= =?UTF-8?q?=E6=8D=AE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/cn/changelog.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/docs/cn/changelog.md b/docs/cn/changelog.md index ae1662bb4..1d904c836 100644 --- a/docs/cn/changelog.md +++ b/docs/cn/changelog.md @@ -14,7 +14,8 @@ - 新增 fixed-effects classical pooling F、one-way entity error-components Breusch-Pagan LM（包含 Baltagi-Li unbalanced-panel 公式）以及 classical one-way entity FE-vs-RE Hausman。计量上不适用的情况返回结构化 reason；Hausman covariance difference 若为奇异 PSD，则使用明确记录的 generalized-inverse/rank extension；若实质 indefinite，则直接报告不可用。 - `PooledOLS.fit()` 与 `FamaMacBeth.fit()` 的可选 `entity_ids` 只用于 Stage-B within/between fit statistics 和 panel BP-LM。Pooled HAC 稳定排序现在让 entity diagnostic metadata 与 X/y 使用完全相同的 permutation；formula missing-row filtering 也会在形成 diagnostics 前对齐 observation-level side arrays。 - 增加 analytic/fitted regression、维护中的 Python 3.9 + Torch 2.0 CPU parity，以及可执行的 `linearmodels==7.0` definition-alignment job。FirstDifference 的外部比较只在两边 transformed sample 定义一致的 panel 上执行；Stage B 不会为了 external gate 静默改变 Stage-A 对内部缺期采用 adjacent-observed-row differencing 的既有契约。 -- 新增 `dev/benchmarks/validate_panel_stage_b_gpu.py` 作为最终 exact-head physical correctness/provenance gate。schema-2 runner 会在请求的 CuPy/Torch CUDA 上对照 NumPy 检查 Stage-B diagnostics/fit statistics，并重新核验 `coef`、BSE、t-value、p-value、confidence interval、`nobs` 与 `df_resid`，以保证新增 diagnostics 不会掩盖 Stage-A inference regression。物理 GPU 验证已在精确 clean implementation head `636988751bcbfad3442d24d3073cdfcd2b3ac637` 上通过：Tesla P100、Python 3.9.16、CuPy 13.6.0、PyTorch 2.0.0；CuPy 与 Torch 各 15 个模型 case 以及 balanced/unbalanced diagnostics 全部成功，无 CPU fallback，Stage-A inference regression 与 NumPy 的差异保持在 machine-precision 量级。 +- 新增 `dev/benchmarks/validate_panel_stage_b_gpu.py` 作为 exact-head physical correctness/provenance gate。最终 schema-2 物理运行已在精确 clean implementation head `faa95ce7fb5cb204088957fbda5544c20a06fbfc` 上通过，环境为 Tesla P100-SXM2-16GB 与 Python 3.9.16：CuPy 与 Torch CUDA 各自通过全部 17 个 estimator case 和 4 个 Hausman diagnostic，无 CPU fallback。explicit-constant RandomEffects 相对 NumPy 的最大 coefficient difference 为 `2.22e-16`，所有 RandomEffects diagnostic contract 都与 NumPy 完全一致。raw metadata 报告 PyTorch 2.0.0；CuPy package-version lookup 为 `null`，因此不再沿用旧运行中的 CuPy 版本信息。 +- 已将 exact-head raw artifact `results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json`（SHA-256 `c1ba014a3b9bb0d32cbc0ca3d844ccfe767e7149189efb9ba2969f5bc1b94b31`）提升为受 SHA 保护的 canonical validation-only frontend source。dashboard 现在发布 42 条 Stage-B validation row：34 条 estimator/backend row 与 8 条 Hausman/backend row；不伪造 timing 或 speedup 字段，并区分 standard Hausman 与 RE-explicit-constant Hausman parameterization。 关联：Issue #93 与 pull request #122。 From dd459fd346877b848ee95edcf81058c08339246b Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 00:27:15 +0800 Subject: [PATCH 102/165] docs: close PR122 physical evidence record --- dev/reviews/pr122_physical_gpu_validation.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dev/reviews/pr122_physical_gpu_validation.md b/dev/reviews/pr122_physical_gpu_validation.md index 5427fbe0a..20a072b20 100644 --- a/dev/reviews/pr122_physical_gpu_validation.md +++ b/dev/reviews/pr122_physical_gpu_validation.md @@ -73,4 +73,4 @@ The canonical frontend source represents 42 validation-only runs: 34 estimator/b The dedicated identity-overhead benchmark remains accepted from the immediately preceding implementation candidate because the `faa95ce7...` repair only changes the explicit-constant RandomEffects auxiliary-within branch, while the benchmark exercises PanelOLS and no-explicit-constant RandomEffects. Its measured digest/no-digest ratios remained approximately 1.04x-1.29x over the maintained target scales. -This exact-head raw artifact supersedes the earlier `636988...` canonical physical record and the failed `9c78bf66...` correctness attempt. Generated frontend assets and hosted staleness/e2e/production gates must be refreshed after canonical promotion before the stale-evidence review thread is closed. +This exact-head raw artifact supersedes the earlier `636988...` canonical physical record and the failed `9c78bf66...` correctness attempt. Canonical promotion is complete: generated frontend assets were refreshed, exact-head hosted staleness/e2e/production QA passed on the evidence head, and the stale-evidence review thread was resolved. \ No newline at end of file From ace884a5cba7e9c40e8ed996cfb064258a678180 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 08:52:11 +0800 Subject: [PATCH 103/165] docs: restore BetweenOLS estimator contract documentation --- statgpu/panel/_between.py | 43 +++++++++++++++++++++++++++++++++++++-- 1 file changed, 41 insertions(+), 2 deletions(-) diff --git a/statgpu/panel/_between.py b/statgpu/panel/_between.py index cd98e9744..c0ee8ca51 100644 --- a/statgpu/panel/_between.py +++ b/statgpu/panel/_between.py @@ -15,7 +15,43 @@ class BetweenOLS(BasePanelModel): - """Between-entity OLS estimator for panel data.""" + """Between-entity OLS estimator for panel data. + + Collapses the data to entity means and runs OLS on the collapsed data. + An intercept is added automatically. + + Parameters + ---------- + cov_type : str, default='nonrobust' + Covariance estimator: ``'nonrobust'`` or ``'robust'`` (HC1). + alpha : float, default=0.05 + Significance level for confidence intervals. + device : str or Device, default='auto' + Computation device. + n_jobs : int or None, default=None + Optional parallelism hint retained by the shared estimator contract. + + Attributes + ---------- + coef_ : ndarray, shape (k,) + Estimated coefficients, including the automatically added intercept. + bse_ : ndarray, shape (k,) + Standard errors. + tvalues_ : ndarray, shape (k,) + t-statistics. + pvalues_ : ndarray, shape (k,) + Two-sided p-values. + conf_int_ : ndarray, shape (k, 2) + Confidence intervals. + rsquared : float + R-squared of the entity-mean regression. + nobs : int + Number of entity-mean observations (groups). + df_resid : int + Residual degrees of freedom of the legacy between regression. + fit_statistics_ : PanelFitStatistics or None + Standardized Stage-B panel fit statistics populated after ``fit``. + """ def __init__( self, @@ -33,6 +69,8 @@ def __init__( def fit(self, X=None, y=None, entity_ids=None, time_ids=None, formula=None, data=None): """Fit the between OLS model.""" + # Preserve the pre-Stage-A requirement: BetweenOLS always requires an + # explicit entity_ids side array, including for formula-based fitting. if entity_ids is None: raise ValueError("entity_ids is required for BetweenOLS") @@ -65,6 +103,7 @@ def fit(self, X=None, y=None, entity_ids=None, time_ids=None, formula=None, data ) n_orig = X_arr.shape[0] + # Add intercept exactly as before. ones = xp.ones((n_orig, 1), dtype=xp.float64) if hasattr(X_arr, "is_cuda"): ones = ones.to(device=X_arr.device) @@ -171,4 +210,4 @@ def get_params(self, deep=True): def set_params(self, **params): """Delegate parameter updates to the shared estimator contract.""" - return super().set_params(**params) \ No newline at end of file + return super().set_params(**params) From ac2f04a15c67d0b5db31b521a2a7581759abb9e8 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 08:52:51 +0800 Subject: [PATCH 104/165] fix: use component-aware FE rank for fit feasibility --- statgpu/panel/_fixed_effects.py | 74 ++++++++++++++++++++++----------- 1 file changed, 49 insertions(+), 25 deletions(-) diff --git a/statgpu/panel/_fixed_effects.py b/statgpu/panel/_fixed_effects.py index f213fd7ce..192b39d82 100644 --- a/statgpu/panel/_fixed_effects.py +++ b/statgpu/panel/_fixed_effects.py @@ -173,16 +173,57 @@ def fit( n_entities = len(entity_labels) if entity_labels is not None else 0 n_times = len(time_labels) if time_labels is not None else 0 + + from statgpu.panel._diagnostic_context import ( + build_diagnostic_identity, + build_model_fit_statistics, + fixed_effect_diagnostic_df, + pooling_f_from_level_arrays, + ) + + # Compute the rank-consistent FE degrees of freedom before deciding + # whether the fit is feasible. For disconnected two-way incidence + # graphs the nuisance rank is N + T - C, so the historical N/T count can + # otherwise reject an identified fit before Stage-B diagnostics run. + diagnostic_df = fixed_effect_diagnostic_df( + X_d, + xp=xp, + nobs=n, + n_entities=n_entities, + n_times=n_times, + entity_effects=self.entity_effects, + time_effects=self.time_effects, + has_constant=False, + entity_codes=entity_arr, + time_codes=time_arr, + ) + + # Preserve the legacy public df whenever it is positive. If the legacy + # count is nonpositive solely because a disconnected two-way panel has a + # lower nuisance rank, use the component-aware df instead so the valid + # fit can proceed. This keeps established connected-panel inference + # unchanged while fixing the false rejection boundary. n_effects = 0 if self.entity_effects: n_effects += n_entities - 1 if self.time_effects: n_effects += n_times - 1 - self.df_resid = n - k - n_effects - if self.df_resid <= 0: + legacy_df_resid = n - k - n_effects + standard_df_resid = int(diagnostic_df["df_resid"]) + if legacy_df_resid > 0: + self.df_resid = legacy_df_resid + public_df_basis = "legacy" + elif standard_df_resid > 0: + self.df_resid = standard_df_resid + public_df_basis = "component-aware" + else: raise ValueError( - f"Not enough observations: n={n}, k={k}, n_effects={n_effects}, " - f"df_resid={self.df_resid}. Check that N*T >> k + effects." + "Not enough observations after fixed-effect rank adjustment: " + f"n={n}, k={k}, legacy_n_effects={n_effects}, " + f"legacy_df_resid={legacy_df_resid}, " + f"effect_rank={diagnostic_df['effect_rank']}, " + f"incidence_components={diagnostic_df['incidence_components']}, " + f"df_resid={standard_df_resid}." ) y_pred = X_d @ coef @@ -266,28 +307,10 @@ def fit( ss_tot = _to_float_scalar(xp.sum((y_d - y_d_mean) ** 2)) self.rsquared_within = 1 - ss_res / ss_tot if ss_tot > 0 else 0.0 - from statgpu.panel._diagnostic_context import ( - build_diagnostic_identity, - build_model_fit_statistics, - fixed_effect_diagnostic_df, - pooling_f_from_level_arrays, - ) - # New standardized diagnostics use the full nuisance-effect rank. This # is intentionally separate from the historical self.df_resid used by - # covariance/t inference above. - diagnostic_df = fixed_effect_diagnostic_df( - X_d, - xp=xp, - nobs=n, - n_entities=n_entities, - n_times=n_times, - entity_effects=self.entity_effects, - time_effects=self.time_effects, - has_constant=False, - entity_codes=entity_arr, - time_codes=time_arr, - ) + # covariance/t inference above, except when a disconnected two-way panel + # requires the component-aware df to avoid a false fit rejection. ss_tot_diag = _to_float_scalar(xp.sum(y_d * y_d)) self.fit_statistics_ = build_model_fit_statistics( y_arr, @@ -306,7 +329,8 @@ def fit( f_has_constant=False, metadata={ "fit_space": "fixed-effect transformed regression", - "legacy_df_resid": int(self.df_resid), + "legacy_df_resid": int(legacy_df_resid), + "public_df_resid_basis": public_df_basis, "diagnostic_df": dict(diagnostic_df), "legacy_rsquared_within": float(self.rsquared_within), }, From d3e942da09e5876b36657e41b60330ded1db9dcc Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 08:53:14 +0800 Subject: [PATCH 105/165] fix: propagate physical validation aggregate failures --- .../frontend_data/parsers/panel_stage_b.py | 77 +++++++++++++------ 1 file changed, 55 insertions(+), 22 deletions(-) diff --git a/dev/benchmarks/frontend_data/parsers/panel_stage_b.py b/dev/benchmarks/frontend_data/parsers/panel_stage_b.py index 5f19c1215..da46c9a97 100644 --- a/dev/benchmarks/frontend_data/parsers/panel_stage_b.py +++ b/dev/benchmarks/frontend_data/parsers/panel_stage_b.py @@ -38,6 +38,33 @@ def _validation(checks: list[str], status: str, filepath: Path) -> dict[str, Any } +def _apply_aggregate_validation_contract( + validation: dict[str, Any], + *, + schema_ok: bool, + source_ok: bool, + backend_ok: bool, + executed_backend_ok: bool, +) -> dict[str, Any]: + """Prevent a failed aggregate physical run from emitting passing rows.""" + failed_metrics: list[str] = [] + if not schema_ok: + failed_metrics.append("source_schema_status_ok") + if not source_ok: + failed_metrics.append("source_validation_status_success") + if not backend_ok: + failed_metrics.append("backend_validation_status_success") + if not executed_backend_ok: + failed_metrics.append("executed_backend_matches_requested") + + if failed_metrics: + validation["status"] = "fail" + validation["checks"].extend( + {"metric": metric, "status": "fail"} for metric in failed_metrics + ) + return validation + + def parse_panel_stage_b_physical_validation( filepath: Path, env_id: str ) -> tuple[list[dict], list[dict], list[str]]: @@ -45,9 +72,11 @@ def parse_panel_stage_b_physical_validation( data = json.loads(filepath.read_text(encoding="utf-8")) warnings: list[str] = [] - if data.get("schema_status") != "ok": + schema_ok = data.get("schema_status") == "ok" + source_ok = data.get("status") == "success" + if not schema_ok: warnings.append(f"{filepath.name}: source schema_status is not ok") - if data.get("status") != "success": + if not source_ok: warnings.append(f"{filepath.name}: physical validation status is not success") if data.get("protocol", {}).get("timing_collected") is not False: warnings.append( @@ -68,8 +97,14 @@ def parse_panel_stage_b_physical_validation( for backend in ("cupy", "torch"): backend_result = data.get("backend_results", {}).get(backend, {}) + backend_ok = backend_result.get("status") == "success" executed_backend = backend_result.get("executed_backend") - if executed_backend != backend: + executed_backend_ok = executed_backend == backend + if not backend_ok: + warnings.append( + f"{filepath.name}: {backend} backend validation status is not success" + ) + if not executed_backend_ok: warnings.append( f"{filepath.name}: requested {backend} but executed {executed_backend!r}" ) @@ -82,15 +117,13 @@ def parse_panel_stage_b_physical_validation( model_id = str(case["model_id"]) model_ids.add(model_id) scale = _scale(case) - validation = _validation(case.get("checks", []), str(status), filepath) - if executed_backend != backend: - validation["status"] = "fail" - validation["checks"].append( - { - "metric": "executed_backend_matches_requested", - "status": "fail", - } - ) + validation = _apply_aggregate_validation_contract( + _validation(case.get("checks", []), str(status), filepath), + schema_ok=schema_ok, + source_ok=source_ok, + backend_ok=backend_ok, + executed_backend_ok=executed_backend_ok, + ) runs.append( { @@ -154,17 +187,17 @@ def parse_panel_stage_b_physical_validation( "label": make_scale_label(n_samples, 2), } status = str(diagnostic.get("status", "failed")) - validation = _validation( - ["hausman_backend_consistency", "backend_provenance"], status, filepath + validation = _apply_aggregate_validation_contract( + _validation( + ["hausman_backend_consistency", "backend_provenance"], + status, + filepath, + ), + schema_ok=schema_ok, + source_ok=source_ok, + backend_ok=backend_ok, + executed_backend_ok=executed_backend_ok, ) - if executed_backend != backend: - validation["status"] = "fail" - validation["checks"].append( - { - "metric": "executed_backend_matches_requested", - "status": "fail", - } - ) method_parts: list[object] = [ "panel-stage-b-physical-validation", "hausman", From 2e920c5946f054a57851ac594469211e85f9bb3f Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 08:53:37 +0800 Subject: [PATCH 106/165] test: cover ready-review panel regressions --- ..._panel_stage_b_ready_review_regressions.py | 119 ++++++++++++++++++ 1 file changed, 119 insertions(+) create mode 100644 dev/tests/test_panel_stage_b_ready_review_regressions.py diff --git a/dev/tests/test_panel_stage_b_ready_review_regressions.py b/dev/tests/test_panel_stage_b_ready_review_regressions.py new file mode 100644 index 000000000..5f8a845ce --- /dev/null +++ b/dev/tests/test_panel_stage_b_ready_review_regressions.py @@ -0,0 +1,119 @@ +"""Regression coverage for findings raised after PR #122 became ready for review.""" + +from __future__ import annotations + +import json +import sys +from pathlib import Path + +import numpy as np + +from statgpu.panel import BetweenOLS, PanelOLS + + +REPO_ROOT = Path(__file__).resolve().parents[2] +if str(REPO_ROOT) not in sys.path: + sys.path.insert(0, str(REPO_ROOT)) + +SOURCE_PATH = ( + REPO_ROOT + / "results" + / "benchmark_frontend_sources" + / "panel_stage_b_pr122_p100_20260808.json" +) + + +def test_disconnected_two_way_fe_uses_component_rank_before_df_gate() -> None: + # Three disconnected entity-time incidence components: two 2x2 blocks and + # one singleton. The true nuisance rank is N + T - C = 7, whereas the + # historical count uses (N - 1) + (T - 1) = 8. + entity = np.asarray([0, 0, 1, 1, 2, 2, 3, 3, 4], dtype=np.int64) + time = np.asarray([0, 1, 0, 1, 2, 3, 2, 3, 4], dtype=np.int64) + X = np.asarray([1.0, -1.0, -1.0, 1.0, 1.0, -1.0, -1.0, 1.0, 0.0]).reshape(-1, 1) + y = np.asarray([1.0, -1.0, -1.0, 1.0, 2.0, -2.0, -2.0, 2.0, 0.0]) + + model = PanelOLS(entity_effects=True, time_effects=True).fit( + X, + y, + entity_ids=entity, + time_ids=time, + ) + + metadata = model.fit_statistics_.metadata + diagnostic_df = metadata["diagnostic_df"] + assert metadata["legacy_df_resid"] == 0 + assert metadata["public_df_resid_basis"] == "component-aware" + assert model.df_resid == 1 + assert diagnostic_df["incidence_components"] == 3 + assert diagnostic_df["effect_rank"] == 7 + assert diagnostic_df["rank_x"] == 1 + assert diagnostic_df["df_resid"] == 1 + assert np.all(np.isfinite(model.bse_)) + + +def _parse_mutated_source(tmp_path: Path, mutate) -> tuple[list[dict], list[str]]: + from dev.benchmarks.frontend_data.parsers import ( + parse_panel_stage_b_physical_validation, + ) + + data = json.loads(SOURCE_PATH.read_text(encoding="utf-8")) + mutate(data) + path = tmp_path / "mutated_panel_stage_b.json" + path.write_text(json.dumps(data), encoding="utf-8") + runs, _models, warnings = parse_panel_stage_b_physical_validation( + path, "test-pr122-aggregate-failure" + ) + return runs, warnings + + +def test_panel_stage_b_parser_rejects_failed_source_summary(tmp_path: Path) -> None: + runs, warnings = _parse_mutated_source( + tmp_path, + lambda data: data.__setitem__("status", "failed"), + ) + + assert len(runs) == 42 + assert any("physical validation status is not success" in item for item in warnings) + assert all(run["metrics"]["validation"]["status"] == "fail" for run in runs) + assert all( + any( + check["metric"] == "source_validation_status_success" + and check["status"] == "fail" + for check in run["metrics"]["validation"]["checks"] + ) + for run in runs + ) + estimator_runs = [run for run in runs if "inference" in run["metrics"]] + assert estimator_runs + assert all(run["metrics"]["inference"]["ok"] is False for run in estimator_runs) + + +def test_panel_stage_b_parser_rejects_failed_backend_summary(tmp_path: Path) -> None: + def mutate(data: dict) -> None: + data["backend_results"]["cupy"]["status"] = "failed" + + runs, warnings = _parse_mutated_source(tmp_path, mutate) + cupy_runs = [run for run in runs if run["backend"] == "cupy"] + torch_runs = [run for run in runs if run["backend"] == "torch"] + + assert len(cupy_runs) == 21 + assert len(torch_runs) == 21 + assert any("cupy backend validation status is not success" in item for item in warnings) + assert all(run["metrics"]["validation"]["status"] == "fail" for run in cupy_runs) + assert all(run["metrics"]["validation"]["status"] == "pass" for run in torch_runs) + assert all( + any( + check["metric"] == "backend_validation_status_success" + and check["status"] == "fail" + for check in run["metrics"]["validation"]["checks"] + ) + for run in cupy_runs + ) + + +def test_between_ols_keeps_detailed_class_contract_docstring() -> None: + doc = BetweenOLS.__doc__ or "" + assert "Collapses the data to entity means" in doc + assert "Parameters" in doc + assert "Attributes" in doc + assert "fit_statistics_" in doc From 62ac38a7fb9d8e1bf6d0a971afc0e23185f5534e Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 08:55:31 +0800 Subject: [PATCH 107/165] test: cover disconnected FE rank on Torch CPU --- dev/tests/test_panel_stage_b_torch_cpu.py | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/dev/tests/test_panel_stage_b_torch_cpu.py b/dev/tests/test_panel_stage_b_torch_cpu.py index 942ee9293..9b10d39b7 100644 --- a/dev/tests/test_panel_stage_b_torch_cpu.py +++ b/dev/tests/test_panel_stage_b_torch_cpu.py @@ -118,6 +118,29 @@ def test_stage_b_panel_fe_torch_cpu_pooling_and_fit_stats_match_numpy(): assert actual.fit_statistics_.metadata["diagnostic_df"] == expected.fit_statistics_.metadata["diagnostic_df"] +def test_stage_b_disconnected_two_way_fe_torch_cpu_uses_component_df(): + entity = np.asarray([0, 0, 1, 1, 2, 2, 3, 3, 4], dtype=np.int64) + time = np.asarray([0, 1, 0, 1, 2, 3, 2, 3, 4], dtype=np.int64) + X = np.asarray([1.0, -1.0, -1.0, 1.0, 1.0, -1.0, -1.0, 1.0, 0.0]).reshape(-1, 1) + y = np.asarray([1.0, -1.0, -1.0, 1.0, 2.0, -2.0, -2.0, 2.0, 0.0]) + X_t, y_t, entity_t, time_t = _torch_arrays(X, y, entity, time) + + expected = PanelOLS(entity_effects=True, time_effects=True).fit( + X, y, entity_ids=entity, time_ids=time + ) + actual = PanelOLS(entity_effects=True, time_effects=True).fit( + X_t, y_t, entity_ids=entity_t, time_ids=time_t + ) + + assert_allclose(actual.coef_, expected.coef_, rtol=1e-10, atol=1e-11) + assert_allclose(actual.bse_, expected.bse_, rtol=1e-10, atol=1e-11) + assert actual.df_resid == expected.df_resid == 1 + assert actual.fit_statistics_.metadata["legacy_df_resid"] == 0 + assert actual.fit_statistics_.metadata["public_df_resid_basis"] == "component-aware" + assert actual.fit_statistics_.metadata["diagnostic_df"] == expected.fit_statistics_.metadata["diagnostic_df"] + assert actual.fit_statistics_.metadata["diagnostic_df"]["incidence_components"] == 3 + + def test_stage_b_random_effects_torch_cpu_fit_stats_and_identity_match_numpy(): X, y, entity, time = _panel(seed=1222) X_t, y_t, entity_t, _ = _torch_arrays(X, y, entity, time) From a491a42cc982a4a795a54c76b33156c3c50932db Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 08:57:49 +0800 Subject: [PATCH 108/165] docs: mark PR122 physical evidence superseded by FE fix --- dev/reviews/pr122_physical_gpu_validation.md | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/dev/reviews/pr122_physical_gpu_validation.md b/dev/reviews/pr122_physical_gpu_validation.md index 20a072b20..7e2a9fbd8 100644 --- a/dev/reviews/pr122_physical_gpu_validation.md +++ b/dev/reviews/pr122_physical_gpu_validation.md @@ -1,5 +1,18 @@ # PR #122 Panel Stage B physical GPU validation +## Current applicability status + +The physical artifact documented below remains an immutable, successful record for exact implementation head `faa95ce7fb5cb204088957fbda5544c20a06fbfc`. It is **not** current exact-head acceptance for the latest PR implementation. + +After the PR was promoted to Ready for review, a fresh review identified that disconnected two-way `PanelOLS` fits could still be rejected by the legacy residual-df feasibility gate before the already-correct `N + T - C` diagnostic rank was applied. Commit `ac2f04a15c67d0b5db31b521a2a7581759abb9e8` changes `statgpu/panel/_fixed_effects.py` so component-aware rank is computed before fit feasibility and is used when the legacy df is nonpositive but the rank-consistent df remains positive. Because this is a statistical implementation change after the physically validated head, repository policy requires a new exact-head CuPy/Torch physical validation before PR #122 can return to merge-ready status. + +Accordingly: + +- the `faa95ce7...` artifact remains valid historical evidence for that exact implementation; +- the canonical frontend source derived from it remains provenance-correct for measurement SHA `faa95ce7...`, but must not be interpreted as validation of the newer FE implementation; +- current PR status is `PARTIAL_REMOTE_PENDING` until a clean exact-head physical run passes and its evidence is audited/promoted; +- PR #122 is intentionally kept Draft while that gate is pending. + Validated implementation head: `faa95ce7fb5cb204088957fbda5544c20a06fbfc`. Raw machine-readable evidence: @@ -73,4 +86,4 @@ The canonical frontend source represents 42 validation-only runs: 34 estimator/b The dedicated identity-overhead benchmark remains accepted from the immediately preceding implementation candidate because the `faa95ce7...` repair only changes the explicit-constant RandomEffects auxiliary-within branch, while the benchmark exercises PanelOLS and no-explicit-constant RandomEffects. Its measured digest/no-digest ratios remained approximately 1.04x-1.29x over the maintained target scales. -This exact-head raw artifact supersedes the earlier `636988...` canonical physical record and the failed `9c78bf66...` correctness attempt. Canonical promotion is complete: generated frontend assets were refreshed, exact-head hosted staleness/e2e/production QA passed on the evidence head, and the stale-evidence review thread was resolved. \ No newline at end of file +For the validated `faa95ce7...` implementation, this exact-head raw artifact superseded the earlier `636988...` canonical physical record and the failed `9c78bf66...` correctness attempt. Canonical promotion for that measurement was complete: generated frontend assets were refreshed, exact-head hosted staleness/e2e/production QA passed on the evidence head, and the stale-evidence review thread was resolved. The later disconnected-FE feasibility repair now requires a new exact-head physical validation before current-code acceptance can be promoted again. From 594b1af1b806cd69f91cf51c6bf0527fabd79f58 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 08:59:22 +0800 Subject: [PATCH 109/165] test: add disconnected FE physical GPU gate --- ...idate_panel_stage_b_disconnected_fe_gpu.py | 352 ++++++++++++++++++ 1 file changed, 352 insertions(+) create mode 100644 dev/benchmarks/validate_panel_stage_b_disconnected_fe_gpu.py diff --git a/dev/benchmarks/validate_panel_stage_b_disconnected_fe_gpu.py b/dev/benchmarks/validate_panel_stage_b_disconnected_fe_gpu.py new file mode 100644 index 000000000..b7c5219d5 --- /dev/null +++ b/dev/benchmarks/validate_panel_stage_b_disconnected_fe_gpu.py @@ -0,0 +1,352 @@ +#!/usr/bin/env python3 +"""Focused physical GPU gate for disconnected two-way PanelOLS rank handling. + +This complements ``validate_panel_stage_b_gpu.py`` after the PR #122 +Ready-for-review fix that moved the component-aware ``N + T - C`` rank ahead +of the fixed-effects residual-df feasibility gate. The fixture is deliberately +chosen so the historical count gives residual df 0 while the correct +component-aware rank gives residual df 1. +""" + +from __future__ import annotations + +import argparse +import importlib.metadata +import json +import platform +import subprocess +from datetime import datetime, timezone +from pathlib import Path + +import numpy as np + +from statgpu.backends import _to_numpy +from statgpu.panel import PanelOLS + + +def _git_sha() -> str: + return subprocess.check_output(["git", "rev-parse", "HEAD"], text=True).strip() + + +def _git_status_porcelain() -> str: + return subprocess.check_output(["git", "status", "--porcelain"], text=True) + + +def _version(name: str): + try: + return importlib.metadata.version(name) + except importlib.metadata.PackageNotFoundError: + return None + + +def _fixture(): + # Two disconnected 2x2 blocks plus one singleton cell. + # N = T = 5, C = 3, n = 9, k = 1. + # Historical nuisance count: (N - 1) + (T - 1) = 8 -> df = 0. + # Correct effect rank: N + T - C = 7 -> df = 1. + entity = np.asarray([0, 0, 1, 1, 2, 2, 3, 3, 4], dtype=np.int64) + time = np.asarray([0, 1, 0, 1, 2, 3, 2, 3, 4], dtype=np.int64) + X = np.asarray( + [1.0, -1.0, -1.0, 1.0, 1.0, -1.0, -1.0, 1.0, 0.0], + dtype=np.float64, + ).reshape(-1, 1) + y = np.asarray( + [1.0, -1.0, -1.0, 1.0, 2.0, -2.0, -2.0, 2.0, 0.0], + dtype=np.float64, + ) + return X, y, entity, time + + +def _to_backend_arrays(X, y, entity, time, backend): + if backend == "numpy": + return X, y, entity, time + if backend == "cupy": + import cupy as cp + + return ( + cp.asarray(X), + cp.asarray(y), + cp.asarray(entity, dtype=cp.int64), + cp.asarray(time, dtype=cp.int64), + ) + if backend == "torch": + import torch + + return ( + torch.as_tensor(X, dtype=torch.float64, device="cuda"), + torch.as_tensor(y, dtype=torch.float64, device="cuda"), + torch.as_tensor(entity, dtype=torch.int64, device="cuda"), + torch.as_tensor(time, dtype=torch.int64, device="cuda"), + ) + raise ValueError(backend) + + +def _device_arg(backend): + return {"numpy": "cpu", "cupy": "cuda", "torch": "torch"}[backend] + + +def _backend_name(model): + return model._get_backend(backend="auto").name + + +def _array(value): + return np.asarray(_to_numpy(value), dtype=np.float64) + + +def _test_result(result): + return { + "applicable": bool(result.applicable), + "reason": result.reason, + "statistic": result.statistic, + "pvalue": result.pvalue, + "df": result.df, + "distribution": result.distribution, + } + + +def _snapshot(model): + fit = model.fit_statistics_ + metadata = fit.metadata + diagnostic_df = metadata["diagnostic_df"] + return { + "coef": _array(model.coef_).ravel().tolist(), + "bse": _array(model.bse_).ravel().tolist(), + "tvalues": _array(model.tvalues_).ravel().tolist(), + "pvalues": _array(model.pvalues_).ravel().tolist(), + "conf_int": _array(model.conf_int_).tolist(), + "nobs": int(model.nobs), + "df_resid": int(model.df_resid), + "rsquared_within": float(model.rsquared_within), + "fit_statistics": { + "rsquared_within": fit.rsquared_within, + "rsquared_between": fit.rsquared_between, + "rsquared_overall": fit.rsquared_overall, + "rsquared_adj": fit.rsquared_adj, + "f_statistic": fit.f_statistic, + "f_pvalue": fit.f_pvalue, + "f_df": None if fit.f_df is None else list(fit.f_df), + }, + "diagnostic_df": { + "effect_rank": int(diagnostic_df["effect_rank"]), + "incidence_components": diagnostic_df["incidence_components"], + "rank_x": int(diagnostic_df["rank_x"]), + "df_resid": int(diagnostic_df["df_resid"]), + "df_total": int(diagnostic_df["df_total"]), + }, + "legacy_df_resid": int(metadata["legacy_df_resid"]), + "public_df_resid_basis": metadata["public_df_resid_basis"], + "pooling_f": _test_result(model.pooling_f_test()), + } + + +def _fit(backend): + X, y, entity, time = _fixture() + Xb, yb, eb, tb = _to_backend_arrays(X, y, entity, time, backend) + model = PanelOLS( + entity_effects=True, + time_effects=True, + cov_type="nonrobust", + device=_device_arg(backend), + ).fit(Xb, yb, entity_ids=eb, time_ids=tb) + return model, _snapshot(model) + + +def _assert_structural_contract(snapshot, *, label): + if snapshot["legacy_df_resid"] != 0: + raise AssertionError(f"{label}: expected legacy df 0") + if snapshot["public_df_resid_basis"] != "component-aware": + raise AssertionError(f"{label}: component-aware public df not used") + if snapshot["df_resid"] != 1: + raise AssertionError(f"{label}: expected public df_resid=1") + diagnostic = snapshot["diagnostic_df"] + expected = { + "effect_rank": 7, + "incidence_components": 3, + "rank_x": 1, + "df_resid": 1, + } + for name, value in expected.items(): + if diagnostic[name] != value: + raise AssertionError( + f"{label}: diagnostic_df[{name!r}]={diagnostic[name]!r} != {value!r}" + ) + + +def _compare(reference, candidate, *, rtol, atol, label): + differences = {} + for field in ("coef", "bse", "tvalues", "pvalues", "conf_int"): + actual = np.asarray(candidate[field], dtype=np.float64) + expected = np.asarray(reference[field], dtype=np.float64) + np.testing.assert_allclose( + actual, + expected, + rtol=rtol, + atol=atol, + err_msg=f"{label}.{field}", + ) + differences[field] = float(np.max(np.abs(actual - expected))) + + for field in ("nobs", "df_resid", "legacy_df_resid"): + if candidate[field] != reference[field]: + raise AssertionError( + f"{label}.{field}: {candidate[field]!r} != {reference[field]!r}" + ) + + if candidate["public_df_resid_basis"] != reference["public_df_resid_basis"]: + raise AssertionError(f"{label}.public_df_resid_basis mismatch") + if candidate["diagnostic_df"] != reference["diagnostic_df"]: + raise AssertionError(f"{label}.diagnostic_df mismatch") + + for field, expected in reference["fit_statistics"].items(): + actual = candidate["fit_statistics"][field] + if expected is None: + if actual is not None: + raise AssertionError(f"{label}.fit_statistics.{field} expected None") + elif field == "f_df": + np.testing.assert_allclose(actual, expected, rtol=0, atol=0) + else: + np.testing.assert_allclose( + actual, + expected, + rtol=rtol, + atol=atol, + err_msg=f"{label}.fit_statistics.{field}", + ) + differences[f"fit_statistics.{field}"] = float(abs(actual - expected)) + + ref_pool = reference["pooling_f"] + cand_pool = candidate["pooling_f"] + for field in ("applicable", "reason", "df", "distribution"): + if cand_pool[field] != ref_pool[field]: + raise AssertionError(f"{label}.pooling_f.{field} mismatch") + for field in ("statistic", "pvalue"): + expected = ref_pool[field] + actual = cand_pool[field] + if expected is None: + if actual is not None: + raise AssertionError(f"{label}.pooling_f.{field} expected None") + else: + np.testing.assert_allclose(actual, expected, rtol=rtol, atol=atol) + differences[f"pooling_f.{field}"] = float(abs(actual - expected)) + return differences + + +def _environment(backends): + gpu = None + if "torch" in backends: + import torch + + if not torch.cuda.is_available(): + raise RuntimeError("Torch backend requested but CUDA is unavailable") + gpu = torch.cuda.get_device_name(0) + elif "cupy" in backends: + import cupy as cp + + if cp.cuda.runtime.getDeviceCount() < 1: + raise RuntimeError("CuPy backend requested but CUDA is unavailable") + props = cp.cuda.runtime.getDeviceProperties(0) + gpu = props["name"].decode() if isinstance(props["name"], bytes) else props["name"] + return { + "python": platform.python_version(), + "platform": platform.platform(), + "gpu": gpu, + "packages": { + name: _version(name) + for name in ("statgpu", "numpy", "scipy", "cupy", "torch") + }, + } + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--out", type=Path, required=True) + parser.add_argument("--backends", default="cupy,torch") + parser.add_argument("--expected-sha", required=True) + parser.add_argument("--rtol", type=float, default=5e-6) + parser.add_argument("--atol", type=float, default=5e-7) + args = parser.parse_args() + + backends = [value.strip() for value in args.backends.split(",") if value.strip()] + if not backends or any(value not in {"cupy", "torch"} for value in backends): + raise ValueError("--backends must contain cupy and/or torch") + + sha = _git_sha() + clean = _git_status_porcelain() == "" + if sha != args.expected_sha: + raise RuntimeError(f"HEAD {sha} != --expected-sha {args.expected_sha}") + if not clean: + raise RuntimeError("working tree must be clean for physical validation") + + reference_model, reference = _fit("numpy") + if _backend_name(reference_model) != "numpy": + raise RuntimeError("NumPy reference did not execute on NumPy") + _assert_structural_contract(reference, label="numpy") + + result = { + "schema_version": 1, + "validation": "panel_stage_b_disconnected_two_way_fe", + "generated_at": datetime.now(timezone.utc).isoformat(), + "git_sha": sha, + "working_tree_clean": clean, + "status": "success", + "protocol": { + "reference_backend": "numpy", + "requested_backends": backends, + "rtol": args.rtol, + "atol": args.atol, + "timing_collected": False, + "fixture": "two disconnected 2x2 blocks plus one singleton", + "expected_rank_contract": { + "nobs": 9, + "n_entities": 5, + "n_times": 5, + "incidence_components": 3, + "effect_rank": 7, + "rank_x": 1, + "legacy_df_resid": 0, + "component_aware_df_resid": 1, + }, + }, + "environment": _environment(backends), + "reference": reference, + "backend_results": {}, + } + + for backend in backends: + try: + model, snapshot = _fit(backend) + executed_backend = _backend_name(model) + if executed_backend != backend: + raise AssertionError( + f"requested {backend}, executed backend {executed_backend!r}" + ) + _assert_structural_contract(snapshot, label=backend) + differences = _compare( + reference, + snapshot, + rtol=args.rtol, + atol=args.atol, + label=backend, + ) + result["backend_results"][backend] = { + "status": "success", + "executed_backend": executed_backend, + "snapshot": snapshot, + "differences_vs_numpy": differences, + } + except Exception as exc: + result["status"] = "failed" + result["backend_results"][backend] = { + "status": "failed", + "error": f"{type(exc).__name__}: {exc}", + } + + args.out.parent.mkdir(parents=True, exist_ok=True) + args.out.write_text(json.dumps(result, indent=2, sort_keys=True), encoding="utf-8") + print(json.dumps(result, indent=2, sort_keys=True)) + if result["status"] != "success": + raise SystemExit(1) + + +if __name__ == "__main__": + main() From f005b772966990a720c28e56ac4e924b4d216223 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 10:30:43 +0800 Subject: [PATCH 110/165] fix: use exact Cauchy boundary for panel df1 inference --- statgpu/panel/_base.py | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/statgpu/panel/_base.py b/statgpu/panel/_base.py index 11ad5db53..c7cbb96a2 100644 --- a/statgpu/panel/_base.py +++ b/statgpu/panel/_base.py @@ -224,12 +224,21 @@ def _panel_store_ols_inference( tvalues_dev = params / denominator dist_name = "t" if str(cov_type).lower() == "nonrobust" else "norm" - distribution = get_distribution(dist_name, backend=backend.name) df = int(df_resid if distribution_df is None else distribution_df) - if dist_name == "t": + if dist_name == "t" and df == 1: + # Student-t with one residual degree of freedom is exactly a + # standard Cauchy distribution. Using this closed-form boundary + # avoids inverse-beta endpoint singularities in backend fallbacks + # while keeping the computation backend-native on NumPy/CuPy/Torch. + distribution = get_distribution("cauchy", backend=backend.name) + pvalues_dev = 2 * distribution.sf(xp.abs(tvalues_dev)) + critical = distribution.isf(float(self.alpha) / 2) + elif dist_name == "t": + distribution = get_distribution("t", backend=backend.name) pvalues_dev = 2 * distribution.sf(xp.abs(tvalues_dev), df) critical = distribution.isf(float(self.alpha) / 2, df) else: + distribution = get_distribution("norm", backend=backend.name) pvalues_dev = 2 * distribution.sf(xp.abs(tvalues_dev)) critical = distribution.isf(float(self.alpha) / 2) critical = xp_asarray( From a57efcea29b0e87ecb89865c5a6902d5773812c6 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 10:31:11 +0800 Subject: [PATCH 111/165] test: lock Torch df1 panel confidence intervals --- dev/tests/test_panel_stage_b_torch_cpu.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/dev/tests/test_panel_stage_b_torch_cpu.py b/dev/tests/test_panel_stage_b_torch_cpu.py index 9b10d39b7..79efc9486 100644 --- a/dev/tests/test_panel_stage_b_torch_cpu.py +++ b/dev/tests/test_panel_stage_b_torch_cpu.py @@ -134,6 +134,9 @@ def test_stage_b_disconnected_two_way_fe_torch_cpu_uses_component_df(): assert_allclose(actual.coef_, expected.coef_, rtol=1e-10, atol=1e-11) assert_allclose(actual.bse_, expected.bse_, rtol=1e-10, atol=1e-11) + assert_allclose(actual.tvalues_, expected.tvalues_, rtol=1e-10, atol=1e-11) + assert_allclose(actual.pvalues_, expected.pvalues_, rtol=1e-10, atol=1e-12) + assert_allclose(actual.conf_int_, expected.conf_int_, rtol=1e-10, atol=1e-10) assert actual.df_resid == expected.df_resid == 1 assert actual.fit_statistics_.metadata["legacy_df_resid"] == 0 assert actual.fit_statistics_.metadata["public_df_resid_basis"] == "component-aware" @@ -255,4 +258,4 @@ def test_stage_b_fama_macbeth_torch_cpu_r2_matches_numpy_without_ols_f(): assert actual.fit_statistics_.rsquared_adj is None assert actual.fit_statistics_.f_statistic is None assert actual.fit_statistics_.f_pvalue is None - assert actual.fit_statistics_.f_df is None + assert actual.fit_statistics_.f_df is None \ No newline at end of file From 72b3279d2028e8ec2af30e138e123aceb611ae8c Mon Sep 17 00:00:00 2001 From: TheHiddenObserver Date: Sun, 9 Aug 2026 12:52:00 +0800 Subject: [PATCH 112/165] benchmark: record PR122 P100 Stage B + disconnected FE validation a57efcea --- ...sconnected_fe_gpu_validation_a57efcea.json | 246 ++++++ ...panel_stage_b_gpu_validation_a57efcea.json | 829 ++++++++++++++++++ 2 files changed, 1075 insertions(+) create mode 100644 results/pr122_p100/panel_stage_b_disconnected_fe_gpu_validation_a57efcea.json create mode 100644 results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json diff --git a/results/pr122_p100/panel_stage_b_disconnected_fe_gpu_validation_a57efcea.json b/results/pr122_p100/panel_stage_b_disconnected_fe_gpu_validation_a57efcea.json new file mode 100644 index 000000000..3bda0b204 --- /dev/null +++ b/results/pr122_p100/panel_stage_b_disconnected_fe_gpu_validation_a57efcea.json @@ -0,0 +1,246 @@ +{ + "backend_results": { + "cupy": { + "differences_vs_numpy": { + "bse": 0.0, + "coef": 2.220446049250313e-16, + "conf_int": 8.881784197001252e-16, + "fit_statistics.f_pvalue": 0.0, + "fit_statistics.f_statistic": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.rsquared_between": 0.0, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_within": 0.0, + "pooling_f.pvalue": 0.0, + "pooling_f.statistic": 0.0, + "pvalues": 0.0, + "tvalues": 4.440892098500626e-16 + }, + "executed_backend": "cupy", + "snapshot": { + "bse": [ + 0.5 + ], + "coef": [ + 1.5 + ], + "conf_int": [ + [ + -4.853102368087348, + 7.853102368087348 + ] + ], + "df_resid": 1, + "diagnostic_df": { + "df_resid": 1, + "df_total": 2, + "effect_rank": 7, + "incidence_components": 3, + "rank_x": 1 + }, + "fit_statistics": { + "f_df": [ + 1.0, + 1.0 + ], + "f_pvalue": 0.2048327646991338, + "f_statistic": 9.0, + "rsquared_adj": 0.8, + "rsquared_between": 0.0, + "rsquared_overall": 0.9, + "rsquared_within": 0.9 + }, + "legacy_df_resid": 0, + "nobs": 9, + "pooling_f": { + "applicable": true, + "df": [ + 6.0, + 1.0 + ], + "distribution": "F", + "pvalue": 1.0, + "reason": null, + "statistic": 0.0 + }, + "public_df_resid_basis": "component-aware", + "pvalues": [ + 0.20483276469913347 + ], + "rsquared_within": 0.9, + "tvalues": [ + 3.0 + ] + }, + "status": "success" + }, + "torch": { + "differences_vs_numpy": { + "bse": 0.0, + "coef": 4.440892098500626e-16, + "conf_int": 8.881784197001252e-16, + "fit_statistics.f_pvalue": 0.0, + "fit_statistics.f_statistic": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.rsquared_between": 0.0, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_within": 0.0, + "pooling_f.pvalue": 0.0, + "pooling_f.statistic": 0.0, + "pvalues": 0.0, + "tvalues": 8.881784197001252e-16 + }, + "executed_backend": "torch", + "snapshot": { + "bse": [ + 0.5 + ], + "coef": [ + 1.5000000000000002 + ], + "conf_int": [ + [ + -4.853102368087348, + 7.853102368087348 + ] + ], + "df_resid": 1, + "diagnostic_df": { + "df_resid": 1, + "df_total": 2, + "effect_rank": 7, + "incidence_components": 3, + "rank_x": 1 + }, + "fit_statistics": { + "f_df": [ + 1.0, + 1.0 + ], + "f_pvalue": 0.2048327646991338, + "f_statistic": 9.0, + "rsquared_adj": 0.8, + "rsquared_between": 0.0, + "rsquared_overall": 0.9, + "rsquared_within": 0.9 + }, + "legacy_df_resid": 0, + "nobs": 9, + "pooling_f": { + "applicable": true, + "df": [ + 6.0, + 1.0 + ], + "distribution": "F", + "pvalue": 1.0, + "reason": null, + "statistic": 0.0 + }, + "public_df_resid_basis": "component-aware", + "pvalues": [ + 0.20483276469913347 + ], + "rsquared_within": 0.9, + "tvalues": [ + 3.0000000000000004 + ] + }, + "status": "success" + } + }, + "environment": { + "gpu": "Tesla P100-SXM2-16GB", + "packages": { + "cupy": null, + "numpy": "1.24.2", + "scipy": "1.10.1", + "statgpu": "0.2.4", + "torch": "2.0.0" + }, + "platform": "Linux-3.10.0-1062.el7.x86_64-x86_64-with-glibc2.31", + "python": "3.9.16" + }, + "generated_at": "2026-08-09T03:37:05.589811+00:00", + "git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "protocol": { + "atol": 5e-07, + "expected_rank_contract": { + "component_aware_df_resid": 1, + "effect_rank": 7, + "incidence_components": 3, + "legacy_df_resid": 0, + "n_entities": 5, + "n_times": 5, + "nobs": 9, + "rank_x": 1 + }, + "fixture": "two disconnected 2x2 blocks plus one singleton", + "reference_backend": "numpy", + "requested_backends": [ + "cupy", + "torch" + ], + "rtol": 5e-06, + "timing_collected": false + }, + "reference": { + "bse": [ + 0.5 + ], + "coef": [ + 1.4999999999999998 + ], + "conf_int": [ + [ + -4.853102368087349, + 7.853102368087349 + ] + ], + "df_resid": 1, + "diagnostic_df": { + "df_resid": 1, + "df_total": 2, + "effect_rank": 7, + "incidence_components": 3, + "rank_x": 1 + }, + "fit_statistics": { + "f_df": [ + 1.0, + 1.0 + ], + "f_pvalue": 0.2048327646991338, + "f_statistic": 9.0, + "rsquared_adj": 0.8, + "rsquared_between": 0.0, + "rsquared_overall": 0.9, + "rsquared_within": 0.9 + }, + "legacy_df_resid": 0, + "nobs": 9, + "pooling_f": { + "applicable": true, + "df": [ + 6.0, + 1.0 + ], + "distribution": "F", + "pvalue": 1.0, + "reason": null, + "statistic": 0.0 + }, + "public_df_resid_basis": "component-aware", + "pvalues": [ + 0.20483276469913347 + ], + "rsquared_within": 0.9, + "tvalues": [ + 2.9999999999999996 + ] + }, + "schema_version": 1, + "status": "success", + "validation": "panel_stage_b_disconnected_two_way_fe", + "working_tree_clean": true +} \ No newline at end of file diff --git a/results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json b/results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json new file mode 100644 index 000000000..254b64776 --- /dev/null +++ b/results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json @@ -0,0 +1,829 @@ +{ + "schema_version": 2, + "generated_at": "2026-08-09T03:37:01.897253Z", + "git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "working_tree_clean": true, + "status": "success", + "environment": { + "python": "3.9.16", + "platform": "Linux-3.10.0-1062.el7.x86_64-x86_64-with-glibc2.31", + "gpu": "Tesla P100-SXM2-16GB", + "packages": { + "statgpu": "0.2.4", + "numpy": "1.24.2", + "scipy": "1.10.1", + "cupy": null, + "torch": "2.0.0" + } + }, + "tolerances": { + "rtol": 5e-06, + "atol": 5e-07 + }, + "datasets": { + "balanced": { + "nobs": 54 + }, + "unbalanced": { + "nobs": 49 + } + }, + "backends": { + "cupy": { + "models": { + "pooled_balanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 5.551115123125783e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 7.105427357601002e-15, + "pvalues": 4.440892098500626e-15, + "conf_int": 6.661338147750939e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 1.1102230246251565e-16, + "fit_statistics.rsquared_between": 7.771561172376096e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 1.4210854715202004e-14, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 1.734723475976807e-18, + "bp_lm.statistic": 1.4210854715202004e-13, + "bp_lm.pvalue": 1.0908587575630828e-35 + } + }, + "pooled_hac_unsorted_balanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 5.551115123125783e-16, + "bse": 2.7755575615628914e-17, + "tvalues": 1.0658141036401503e-14, + "pvalues": 1.1964340379966992e-20, + "conf_int": 6.661338147750939e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 2.220446049250313e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 1.4210854715202004e-14, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 3.469446951953614e-18, + "bp_lm.statistic": 7.105427357601002e-14, + "bp_lm.pvalue": 4.8430367253878245e-36 + } + }, + "between_balanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 5.551115123125783e-17, + "bse": 5.551115123125783e-17, + "tvalues": 4.440892098500626e-16, + "pvalues": 2.7755575615628914e-16, + "conf_int": 1.6653345369377348e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 0.0, + "fit_statistics.rsquared_overall": 3.3306690738754696e-16, + "fit_statistics.rsquared_adj": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 0.0, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 2.7755575615628914e-17 + } + }, + "first_difference_balanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 6.938893903907228e-18, + "tvalues": 0.0, + "pvalues": 1.9665546849844295e-156, + "conf_int": 1.1102230246251565e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 5.684341886080801e-13, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 4.336808689942018e-19 + } + }, + "panel_entity_balanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 0.0, + "bse": 6.938893903907228e-18, + "tvalues": 7.105427357601002e-15, + "pvalues": 0.0, + "conf_int": 1.1102230246251565e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 2.220446049250313e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 1.1368683772161603e-13, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 4.336808689942018e-19, + "pooling_f.statistic": 2.1316282072803006e-14, + "pooling_f.pvalue": 0.0 + } + }, + "random_effects_balanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 7.105427357601002e-15, + "pvalues": 0.0, + "conf_int": 1.1102230246251565e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 0.0, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 5.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 8.673617379884035e-19, + "random_effects_diagnostic_contract": 0.0 + } + }, + "random_effects_explicit_constant_balanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 9.71445146547012e-17, + "bse": 1.3877787807814457e-17, + "tvalues": 3.552713678800501e-15, + "pvalues": 4.440892098500626e-16, + "conf_int": 1.1102230246251565e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 0.0, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 0.0, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 1.734723475976807e-18, + "random_effects_diagnostic_contract": 0.0 + } + }, + "fama_macbeth_balanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 3.552713678800501e-15, + "pvalues": 5.421010862427522e-18, + "conf_int": 2.220446049250313e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 2.220446049250313e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 0.0, + "fit_statistics.f_pvalue": 0.0 + } + }, + "panel_two_way_balanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 3.3306690738754696e-16, + "bse": 0.0, + "tvalues": 7.105427357601002e-15, + "pvalues": 0.0, + "conf_int": 3.3306690738754696e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 2.220446049250313e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 5.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 4.0657581468206416e-20, + "pooling_f.statistic": 0.0, + "pooling_f.pvalue": 0.0 + } + }, + "pooled_unbalanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 0.0, + "tvalues": 3.552713678800501e-15, + "pvalues": 1.9984014443252818e-15, + "conf_int": 2.220446049250313e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 0.0, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 1.4210854715202004e-14, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 1.0842021724855044e-19, + "bp_lm.statistic": 2.842170943040401e-14, + "bp_lm.pvalue": 1.7333369499485123e-33 + } + }, + "pooled_hac_unsorted_unbalanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 4.996003610813204e-16, + "bse": 2.7755575615628914e-17, + "tvalues": 5.995204332975845e-15, + "pvalues": 3.3306690738754696e-15, + "conf_int": 5.551115123125783e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 1.1102230246251565e-16, + "fit_statistics.rsquared_between": 2.220446049250313e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 2.842170943040401e-14, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 4.0115480381963664e-18, + "bp_lm.statistic": 0.0, + "bp_lm.pvalue": 0.0 + } + }, + "between_unbalanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 2.7755575615628914e-17, + "tvalues": 2.220446049250313e-16, + "pvalues": 1.1102230246251565e-16, + "conf_int": 4.440892098500626e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 1.1102230246251565e-16, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 2.220446049250313e-16, + "fit_statistics.f_statistic": 7.771561172376096e-16, + "fit_statistics.f_pvalue": 3.3306690738754696e-16, + "diagnostic_covariance": 5.551115123125783e-17 + } + }, + "first_difference_unbalanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 0.0, + "bse": 3.469446951953614e-18, + "tvalues": 7.105427357601002e-15, + "pvalues": 6.9283089726601085e-121, + "conf_int": 0.0, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 1.1368683772161603e-13, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 1.0842021724855044e-19 + } + }, + "panel_entity_unbalanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 6.938893903907228e-18, + "tvalues": 0.0, + "pvalues": 0.0, + "conf_int": 2.220446049250313e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 2.2737367544323206e-13, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 3.2526065174565133e-19, + "pooling_f.statistic": 7.105427357601002e-15, + "pooling_f.pvalue": 0.0 + } + }, + "random_effects_unbalanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 6.938893903907228e-18, + "tvalues": 5.329070518200751e-15, + "pvalues": 0.0, + "conf_int": 1.1102230246251565e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 2.2737367544323206e-13, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 2.168404344971009e-19, + "random_effects_diagnostic_contract": 0.0 + } + }, + "random_effects_explicit_constant_unbalanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 4.163336342344337e-17, + "bse": 1.3877787807814457e-17, + "tvalues": 7.105427357601002e-15, + "pvalues": 0.0, + "conf_int": 8.326672684688674e-17, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 2.220446049250313e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 5.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 3.469446951953614e-18, + "random_effects_diagnostic_contract": 0.0 + } + }, + "fama_macbeth_unbalanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 5.551115123125783e-17, + "tvalues": 5.329070518200751e-15, + "pvalues": 2.220446049250313e-16, + "conf_int": 4.440892098500626e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 1.1102230246251565e-16, + "fit_statistics.rsquared_between": 0.0, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 0.0, + "fit_statistics.f_pvalue": 0.0 + } + } + }, + "diagnostics": { + "hausman_balanced": { + "status": "success", + "max_abs_differences": { + "statistic": 0.0, + "pvalue": 0.0 + }, + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_explicit_re_constant_balanced": { + "status": "success", + "max_abs_differences": { + "statistic": 0.0, + "pvalue": 0.0 + }, + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_unbalanced": { + "status": "success", + "max_abs_differences": { + "statistic": 0.0, + "pvalue": 0.0 + }, + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_explicit_re_constant_unbalanced": { + "status": "success", + "max_abs_differences": { + "statistic": 0.0, + "pvalue": 0.0 + }, + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + } + } + }, + "torch": { + "models": { + "pooled_balanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 6.661338147750939e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 8.881784197001252e-15, + "pvalues": 1.1275609692606992e-06, + "conf_int": 1.6652982326448296e-09, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 2.220446049250313e-16, + "fit_statistics.rsquared_between": 8.881784197001252e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 1.4210854715202004e-14, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 1.734723475976807e-18, + "bp_lm.statistic": 2.4158453015843406e-13, + "bp_lm.pvalue": 1.9325127127518407e-35 + } + }, + "pooled_hac_unsorted_balanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 6.661338147750939e-16, + "bse": 2.7755575615628914e-17, + "tvalues": 1.0658141036401503e-14, + "pvalues": 1.7470054537119944e-20, + "conf_int": 6.661338147750939e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 1.1102230246251565e-16, + "fit_statistics.rsquared_between": 3.3306690738754696e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 1.4210854715202004e-14, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 3.903127820947816e-18, + "bp_lm.statistic": 1.7053025658242404e-13, + "bp_lm.pvalue": 1.3259576277275403e-35 + } + }, + "between_balanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 5.551115123125783e-17, + "bse": 1.1102230246251565e-16, + "tvalues": 6.661338147750939e-16, + "pvalues": 2.7755575615628914e-16, + "conf_int": 1.6653345369377348e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 2.220446049250313e-16, + "fit_statistics.rsquared_overall": 2.220446049250313e-16, + "fit_statistics.rsquared_adj": 3.3306690738754696e-16, + "fit_statistics.f_statistic": 1.7763568394002505e-15, + "fit_statistics.f_pvalue": 3.3306690738754696e-16, + "diagnostic_covariance": 5.551115123125783e-17 + } + }, + "first_difference_balanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 0.0, + "bse": 1.3877787807814457e-17, + "tvalues": 1.4210854715202004e-14, + "pvalues": 8.539945807941643e-156, + "conf_int": 5.551115123125783e-17, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 3.3306690738754696e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 3.410605131648481e-13, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 7.589415207398531e-19 + } + }, + "panel_entity_balanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 3.469446951953614e-18, + "tvalues": 3.552713678800501e-15, + "pvalues": 0.0, + "conf_int": 4.719586943480181e-10, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 3.3306690738754696e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 1.1368683772161603e-13, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 2.168404344971009e-19, + "pooling_f.statistic": 7.105427357601002e-15, + "pooling_f.pvalue": 0.0 + } + }, + "random_effects_balanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 0.0, + "tvalues": 3.552713678800501e-15, + "pvalues": 0.0, + "conf_int": 6.353757520116687e-10, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 0.0, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 0.0, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 2.168404344971009e-19, + "random_effects_diagnostic_contract": 0.0 + } + }, + "random_effects_explicit_constant_balanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 1.3877787807814457e-17, + "bse": 1.3877787807814457e-17, + "tvalues": 3.552713678800501e-15, + "pvalues": 2.841572954714877e-08, + "conf_int": 1.8457834149998575e-09, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 4.440892098500626e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 1.7053025658242404e-13, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 1.734723475976807e-18, + "random_effects_diagnostic_contract": 0.0 + } + }, + "fama_macbeth_balanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 5.551115123125783e-17, + "bse": 1.3877787807814457e-17, + "tvalues": 1.7763568394002505e-15, + "pvalues": 3.2526065174565133e-18, + "conf_int": 1.1102230246251565e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 0.0, + "fit_statistics.rsquared_overall": 2.220446049250313e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 0.0, + "fit_statistics.f_pvalue": 0.0 + } + }, + "panel_two_way_balanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 3.3306690738754696e-16, + "bse": 6.938893903907228e-18, + "tvalues": 3.552713678800501e-15, + "pvalues": 0.0, + "conf_int": 4.125351171779812e-10, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 3.3306690738754696e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 5.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 2.168404344971009e-19, + "pooling_f.statistic": 1.4210854715202004e-14, + "pooling_f.pvalue": 0.0 + } + }, + "pooled_unbalanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 4.0245584642661925e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 5.329070518200751e-15, + "pvalues": 6.327377473080986e-07, + "conf_int": 1.3248322994208195e-09, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 0.0, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 1.734723475976807e-18, + "bp_lm.statistic": 9.947598300641403e-14, + "bp_lm.pvalue": 6.0426052005149525e-33 + } + }, + "pooled_hac_unsorted_unbalanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 6.106226635438361e-16, + "bse": 2.7755575615628914e-17, + "tvalues": 9.2148511043888e-15, + "pvalues": 4.9960036108132044e-15, + "conf_int": 6.38378239159465e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 1.1102230246251565e-16, + "fit_statistics.rsquared_between": 0.0, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 2.842170943040401e-14, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 5.366800753803247e-18, + "bp_lm.statistic": 2.842170943040401e-14, + "bp_lm.pvalue": 1.7333369499485123e-33 + } + }, + "between_unbalanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 0.0, + "tvalues": 2.220446049250313e-16, + "pvalues": 1.1102230246251565e-16, + "conf_int": 4.440892098500626e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 2.220446049250313e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 4.440892098500626e-16, + "fit_statistics.f_statistic": 1.4432899320127035e-15, + "fit_statistics.f_pvalue": 5.551115123125783e-16, + "diagnostic_covariance": 6.938893903907228e-17 + } + }, + "first_difference_unbalanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 0.0, + "bse": 6.938893903907228e-18, + "tvalues": 2.1316282072803006e-14, + "pvalues": 6.9283089726601085e-121, + "conf_int": 0.0, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 0.0, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 1.1368683772161603e-13, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 2.710505431213761e-19 + } + }, + "panel_entity_unbalanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 3.469446951953614e-18, + "tvalues": 1.4210854715202004e-14, + "pvalues": 0.0, + "conf_int": 2.8987834355120867e-10, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 2.220446049250313e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 3.410605131648481e-13, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 2.168404344971009e-19, + "pooling_f.statistic": 7.105427357601002e-15, + "pooling_f.pvalue": 0.0 + } + }, + "random_effects_unbalanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 0.0, + "tvalues": 3.552713678800501e-15, + "pvalues": 0.0, + "conf_int": 5.262852376120009e-10, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 0.0, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 0.0, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 0.0, + "random_effects_diagnostic_contract": 0.0 + } + }, + "random_effects_explicit_constant_unbalanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 1.4210854715202004e-14, + "pvalues": 2.1985840481519858e-08, + "conf_int": 1.818750788862289e-09, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 3.3306690738754696e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 1.1368683772161603e-13, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 1.734723475976807e-18, + "random_effects_diagnostic_contract": 0.0 + } + }, + "fama_macbeth_unbalanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 4.440892098500626e-16, + "bse": 8.326672684688674e-17, + "tvalues": 5.329070518200751e-15, + "pvalues": 1.6263032587282567e-19, + "conf_int": 6.661338147750939e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 1.1102230246251565e-16, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 2.220446049250313e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 0.0, + "fit_statistics.f_pvalue": 0.0 + } + } + }, + "diagnostics": { + "hausman_balanced": { + "status": "success", + "max_abs_differences": { + "statistic": 0.0, + "pvalue": 0.0 + }, + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_explicit_re_constant_balanced": { + "status": "success", + "max_abs_differences": { + "statistic": 0.0, + "pvalue": 0.0 + }, + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_unbalanced": { + "status": "success", + "max_abs_differences": { + "statistic": 0.0, + "pvalue": 0.0 + }, + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_explicit_re_constant_unbalanced": { + "status": "success", + "max_abs_differences": { + "statistic": 0.0, + "pvalue": 0.0 + }, + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + } + } + } + } +} From 1b0af419bc7c16315a45686d846ef1f0b56dbaca Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 13:52:28 +0800 Subject: [PATCH 113/165] benchmark: promote PR122 a57efcea physical evidence --- .../panel_stage_b_pr122_p100_20260809.json | 166 ++++++++++++++++++ 1 file changed, 166 insertions(+) create mode 100644 results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809.json diff --git a/results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809.json b/results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809.json new file mode 100644 index 000000000..c9b384e36 --- /dev/null +++ b/results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809.json @@ -0,0 +1,166 @@ +{ + "method": "Panel Tier-1 Stage B physical GPU validation", + "source_schema_version": "1.0", + "source_date": "2026-08-09", + "git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "working_tree_clean": true, + "status": "success", + "schema_status": "ok", + "raw_artifact": { + "path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "repository_commit": "72b3279d2028e8ec2af30e138e123aceb611ae8c", + "git_blob_sha": "254b64776bff4e3b2b642bb4a2ae1eea25f4751c", + "generated_at": "2026-08-09T03:37:01.897253Z", + "schema_version": 2 + }, + "focused_artifact": { + "path": "results/pr122_p100/panel_stage_b_disconnected_fe_gpu_validation_a57efcea.json", + "repository_commit": "72b3279d2028e8ec2af30e138e123aceb611ae8c", + "git_blob_sha": "3bda0b2040479ba8201e2722eb990ba086c3f3b9", + "generated_at": "2026-08-09T03:37:05.589811+00:00", + "schema_version": 1, + "validation": "panel_stage_b_disconnected_two_way_fe", + "status": "success" + }, + "environment": { + "env_id": "remote-p100-pr122-20260809", + "gpu": "Tesla P100-SXM2-16GB", + "cpu": "x86_64", + "platform": "Linux-3.10.0-1062.el7.x86_64-x86_64-with-glibc2.31", + "python": "3.9.16", + "packages": { + "statgpu": "0.2.4", + "numpy": "1.24.2", + "scipy": "1.10.1", + "cupy": null, + "torch": "2.0.0" + }, + "available_backends": [ + "cupy", + "torch" + ] + }, + "protocol": { + "runner": "dev/benchmarks/validate_panel_stage_b_gpu.py", + "focused_runner": "dev/benchmarks/validate_panel_stage_b_disconnected_fe_gpu.py", + "runner_schema_version": 2, + "focused_runner_schema_version": 1, + "reference_backend": "numpy", + "dtype": "float64", + "timing_collected": false, + "failure_policy": "fail_on_backend_mismatch_or_precision_regression", + "rtol": 5e-06, + "atol": 5e-07 + }, + "backend_times": { + "numpy": null, + "cupy": null, + "torch": null + }, + "external_baseline": { + "name": "statgpu NumPy reference", + "time": null, + "version": null + }, + "precision_vs_external": {}, + "convergence_status": {}, + "backend_precision": { + "cupy": "pass", + "torch": "pass" + }, + "compatibility_matrix": { + "cupy": { + "model_cases": "17/17", + "diagnostics": "4/4", + "executed_backend": "cupy", + "cpu_fallback": false, + "disconnected_fe": "pass" + }, + "torch": { + "model_cases": "17/17", + "diagnostics": "4/4", + "executed_backend": "torch", + "cpu_fallback": false, + "disconnected_fe": "pass" + } + }, + "inference_matrix": { + "status": "pass", + "fields": [ + "coef", + "bse", + "tvalues", + "pvalues", + "conf_int", + "nobs", + "df_resid" + ], + "reference": "statgpu NumPy", + "reported_precision": "Full Stage-B matrix passed validator tolerances on CuPy/Torch; the focused disconnected two-way FE case passed with df_resid=1, effect_rank=7, incidence_components=3, and confidence-interval differences at floating-point noise." + }, + "validation_tier": "remote-full", + "timing_scope": { + "collected": false, + "reason": "Correctness/backend-provenance validation only; no benchmark timing was measured." + }, + "reproducibility": { + "exact_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "working_tree_clean": true, + "runner": "dev/benchmarks/validate_panel_stage_b_gpu.py", + "focused_runner": "dev/benchmarks/validate_panel_stage_b_disconnected_fe_gpu.py", + "raw_artifact_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "raw_artifact_git_blob_sha": "254b64776bff4e3b2b642bb4a2ae1eea25f4751c", + "focused_artifact_path": "results/pr122_p100/panel_stage_b_disconnected_fe_gpu_validation_a57efcea.json", + "focused_artifact_git_blob_sha": "3bda0b2040479ba8201e2722eb990ba086c3f3b9", + "repository_commit": "72b3279d2028e8ec2af30e138e123aceb611ae8c" + }, + "uncovered_reasons": [ + "Performance timing was not collected by this correctness-only physical validation and must not be inferred from this source.", + "All standard and explicit-RE-constant Hausman validation datasets produced materially indefinite covariance differences; applicability/reason parity against NumPy is recorded.", + "The runner could not resolve an installed CuPy distribution version through importlib.metadata, so the source records the CuPy package version as null while executed_backend='cupy' proves physical backend execution.", + "The focused disconnected-FE artifact is retained as validation evidence and is not expanded into separate dashboard timing rows." + ], + "case_catalog": [ + {"case_id":"pooled_balanced","model_id":"PooledOLS","variant":"balanced","n_samples":54,"n_features":2,"checks":["fit_statistics","bp_lm","diagnostic_covariance","stage_a_inference","backend_provenance"]}, + {"case_id":"pooled_hac_unsorted_balanced","model_id":"PooledOLS","variant":"balanced-hac-unsorted","n_samples":54,"n_features":2,"checks":["fit_statistics","bp_lm","diagnostic_covariance","stage_a_inference","metadata_sort_alignment","backend_provenance"]}, + {"case_id":"between_balanced","model_id":"BetweenOLS","variant":"balanced","n_samples":54,"n_features":2,"checks":["fit_statistics","diagnostic_covariance","stage_a_inference","backend_provenance"]}, + {"case_id":"first_difference_balanced","model_id":"FirstDifferenceOLS","variant":"balanced","n_samples":54,"n_features":2,"checks":["fit_statistics","diagnostic_covariance","stage_a_inference","backend_provenance"]}, + {"case_id":"panel_entity_balanced","model_id":"PanelOLS","variant":"entity-fe-balanced","n_samples":54,"n_features":2,"checks":["fit_statistics","pooling_f","diagnostic_covariance","stage_a_inference","backend_provenance"]}, + {"case_id":"random_effects_balanced","model_id":"RandomEffects","variant":"balanced","n_samples":54,"n_features":2,"checks":["fit_statistics","diagnostic_covariance","stage_a_inference","random_effects_diagnostic_contract","backend_provenance"]}, + {"case_id":"random_effects_explicit_constant_balanced","model_id":"RandomEffects","variant":"explicit-constant-balanced","n_samples":54,"n_features":3,"checks":["fit_statistics","diagnostic_covariance","stage_a_inference","random_effects_diagnostic_contract","backend_provenance"]}, + {"case_id":"fama_macbeth_balanced","model_id":"FamaMacBeth","variant":"balanced","n_samples":54,"n_features":2,"checks":["fit_statistics","diagnostic_covariance","stage_a_inference","backend_provenance"]}, + {"case_id":"panel_two_way_balanced","model_id":"PanelOLS","variant":"two-way-fe-balanced","n_samples":54,"n_features":2,"checks":["fit_statistics","pooling_f","diagnostic_covariance","stage_a_inference","backend_provenance"]}, + {"case_id":"pooled_unbalanced","model_id":"PooledOLS","variant":"unbalanced","n_samples":49,"n_features":2,"checks":["fit_statistics","bp_lm","diagnostic_covariance","stage_a_inference","backend_provenance"]}, + {"case_id":"pooled_hac_unsorted_unbalanced","model_id":"PooledOLS","variant":"unbalanced-hac-unsorted","n_samples":49,"n_features":2,"checks":["fit_statistics","bp_lm","diagnostic_covariance","stage_a_inference","metadata_sort_alignment","backend_provenance"]}, + {"case_id":"between_unbalanced","model_id":"BetweenOLS","variant":"unbalanced","n_samples":49,"n_features":2,"checks":["fit_statistics","diagnostic_covariance","stage_a_inference","backend_provenance"]}, + {"case_id":"first_difference_unbalanced","model_id":"FirstDifferenceOLS","variant":"unbalanced","n_samples":49,"n_features":2,"checks":["fit_statistics","diagnostic_covariance","stage_a_inference","backend_provenance"]}, + {"case_id":"panel_entity_unbalanced","model_id":"PanelOLS","variant":"entity-fe-unbalanced","n_samples":49,"n_features":2,"checks":["fit_statistics","pooling_f","diagnostic_covariance","stage_a_inference","backend_provenance"]}, + {"case_id":"random_effects_unbalanced","model_id":"RandomEffects","variant":"unbalanced","n_samples":49,"n_features":2,"checks":["fit_statistics","diagnostic_covariance","stage_a_inference","random_effects_diagnostic_contract","backend_provenance"]}, + {"case_id":"random_effects_explicit_constant_unbalanced","model_id":"RandomEffects","variant":"explicit-constant-unbalanced","n_samples":49,"n_features":3,"checks":["fit_statistics","diagnostic_covariance","stage_a_inference","random_effects_diagnostic_contract","backend_provenance"]}, + {"case_id":"fama_macbeth_unbalanced","model_id":"FamaMacBeth","variant":"unbalanced","n_samples":49,"n_features":2,"checks":["fit_statistics","diagnostic_covariance","stage_a_inference","backend_provenance"]} + ], + "backend_results": { + "cupy": { + "status": "success", + "executed_backend": "cupy", + "model_cases": {"pooled_balanced":"success","pooled_hac_unsorted_balanced":"success","between_balanced":"success","first_difference_balanced":"success","panel_entity_balanced":"success","random_effects_balanced":"success","random_effects_explicit_constant_balanced":"success","fama_macbeth_balanced":"success","panel_two_way_balanced":"success","pooled_unbalanced":"success","pooled_hac_unsorted_unbalanced":"success","between_unbalanced":"success","first_difference_unbalanced":"success","panel_entity_unbalanced":"success","random_effects_unbalanced":"success","random_effects_explicit_constant_unbalanced":"success","fama_macbeth_unbalanced":"success"}, + "diagnostics": { + "hausman_balanced":{"status":"success","applicable":false,"reason":"covariance difference is not positive semidefinite"}, + "hausman_explicit_re_constant_balanced":{"status":"success","applicable":false,"reason":"covariance difference is not positive semidefinite"}, + "hausman_unbalanced":{"status":"success","applicable":false,"reason":"covariance difference is not positive semidefinite"}, + "hausman_explicit_re_constant_unbalanced":{"status":"success","applicable":false,"reason":"covariance difference is not positive semidefinite"} + } + }, + "torch": { + "status": "success", + "executed_backend": "torch", + "model_cases": {"pooled_balanced":"success","pooled_hac_unsorted_balanced":"success","between_balanced":"success","first_difference_balanced":"success","panel_entity_balanced":"success","random_effects_balanced":"success","random_effects_explicit_constant_balanced":"success","fama_macbeth_balanced":"success","panel_two_way_balanced":"success","pooled_unbalanced":"success","pooled_hac_unsorted_unbalanced":"success","between_unbalanced":"success","first_difference_unbalanced":"success","panel_entity_unbalanced":"success","random_effects_unbalanced":"success","random_effects_explicit_constant_unbalanced":"success","fama_macbeth_unbalanced":"success"}, + "diagnostics": { + "hausman_balanced":{"status":"success","applicable":false,"reason":"covariance difference is not positive semidefinite"}, + "hausman_explicit_re_constant_balanced":{"status":"success","applicable":false,"reason":"covariance difference is not positive semidefinite"}, + "hausman_unbalanced":{"status":"success","applicable":false,"reason":"covariance difference is not positive semidefinite"}, + "hausman_explicit_re_constant_unbalanced":{"status":"success","applicable":false,"reason":"covariance difference is not positive semidefinite"} + } + } + } +} From 5bd46808d6eb64ebd93932c924642b7baee35787 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 13:53:15 +0800 Subject: [PATCH 114/165] benchmark: normalize PR122 canonical evidence --- .../panel_stage_b_pr122_p100_20260809.json | 339 ++++++++++++++++-- 1 file changed, 312 insertions(+), 27 deletions(-) diff --git a/results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809.json b/results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809.json index c9b384e36..a24a9ab9a 100644 --- a/results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809.json +++ b/results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809.json @@ -121,45 +121,330 @@ "The focused disconnected-FE artifact is retained as validation evidence and is not expanded into separate dashboard timing rows." ], "case_catalog": [ - {"case_id":"pooled_balanced","model_id":"PooledOLS","variant":"balanced","n_samples":54,"n_features":2,"checks":["fit_statistics","bp_lm","diagnostic_covariance","stage_a_inference","backend_provenance"]}, - {"case_id":"pooled_hac_unsorted_balanced","model_id":"PooledOLS","variant":"balanced-hac-unsorted","n_samples":54,"n_features":2,"checks":["fit_statistics","bp_lm","diagnostic_covariance","stage_a_inference","metadata_sort_alignment","backend_provenance"]}, - {"case_id":"between_balanced","model_id":"BetweenOLS","variant":"balanced","n_samples":54,"n_features":2,"checks":["fit_statistics","diagnostic_covariance","stage_a_inference","backend_provenance"]}, - {"case_id":"first_difference_balanced","model_id":"FirstDifferenceOLS","variant":"balanced","n_samples":54,"n_features":2,"checks":["fit_statistics","diagnostic_covariance","stage_a_inference","backend_provenance"]}, - {"case_id":"panel_entity_balanced","model_id":"PanelOLS","variant":"entity-fe-balanced","n_samples":54,"n_features":2,"checks":["fit_statistics","pooling_f","diagnostic_covariance","stage_a_inference","backend_provenance"]}, - {"case_id":"random_effects_balanced","model_id":"RandomEffects","variant":"balanced","n_samples":54,"n_features":2,"checks":["fit_statistics","diagnostic_covariance","stage_a_inference","random_effects_diagnostic_contract","backend_provenance"]}, - {"case_id":"random_effects_explicit_constant_balanced","model_id":"RandomEffects","variant":"explicit-constant-balanced","n_samples":54,"n_features":3,"checks":["fit_statistics","diagnostic_covariance","stage_a_inference","random_effects_diagnostic_contract","backend_provenance"]}, - {"case_id":"fama_macbeth_balanced","model_id":"FamaMacBeth","variant":"balanced","n_samples":54,"n_features":2,"checks":["fit_statistics","diagnostic_covariance","stage_a_inference","backend_provenance"]}, - {"case_id":"panel_two_way_balanced","model_id":"PanelOLS","variant":"two-way-fe-balanced","n_samples":54,"n_features":2,"checks":["fit_statistics","pooling_f","diagnostic_covariance","stage_a_inference","backend_provenance"]}, - {"case_id":"pooled_unbalanced","model_id":"PooledOLS","variant":"unbalanced","n_samples":49,"n_features":2,"checks":["fit_statistics","bp_lm","diagnostic_covariance","stage_a_inference","backend_provenance"]}, - {"case_id":"pooled_hac_unsorted_unbalanced","model_id":"PooledOLS","variant":"unbalanced-hac-unsorted","n_samples":49,"n_features":2,"checks":["fit_statistics","bp_lm","diagnostic_covariance","stage_a_inference","metadata_sort_alignment","backend_provenance"]}, - {"case_id":"between_unbalanced","model_id":"BetweenOLS","variant":"unbalanced","n_samples":49,"n_features":2,"checks":["fit_statistics","diagnostic_covariance","stage_a_inference","backend_provenance"]}, - {"case_id":"first_difference_unbalanced","model_id":"FirstDifferenceOLS","variant":"unbalanced","n_samples":49,"n_features":2,"checks":["fit_statistics","diagnostic_covariance","stage_a_inference","backend_provenance"]}, - {"case_id":"panel_entity_unbalanced","model_id":"PanelOLS","variant":"entity-fe-unbalanced","n_samples":49,"n_features":2,"checks":["fit_statistics","pooling_f","diagnostic_covariance","stage_a_inference","backend_provenance"]}, - {"case_id":"random_effects_unbalanced","model_id":"RandomEffects","variant":"unbalanced","n_samples":49,"n_features":2,"checks":["fit_statistics","diagnostic_covariance","stage_a_inference","random_effects_diagnostic_contract","backend_provenance"]}, - {"case_id":"random_effects_explicit_constant_unbalanced","model_id":"RandomEffects","variant":"explicit-constant-unbalanced","n_samples":49,"n_features":3,"checks":["fit_statistics","diagnostic_covariance","stage_a_inference","random_effects_diagnostic_contract","backend_provenance"]}, - {"case_id":"fama_macbeth_unbalanced","model_id":"FamaMacBeth","variant":"unbalanced","n_samples":49,"n_features":2,"checks":["fit_statistics","diagnostic_covariance","stage_a_inference","backend_provenance"]} + { + "case_id": "pooled_balanced", + "model_id": "PooledOLS", + "variant": "balanced", + "n_samples": 54, + "n_features": 2, + "checks": [ + "fit_statistics", + "bp_lm", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + }, + { + "case_id": "pooled_hac_unsorted_balanced", + "model_id": "PooledOLS", + "variant": "balanced-hac-unsorted", + "n_samples": 54, + "n_features": 2, + "checks": [ + "fit_statistics", + "bp_lm", + "diagnostic_covariance", + "stage_a_inference", + "metadata_sort_alignment", + "backend_provenance" + ] + }, + { + "case_id": "between_balanced", + "model_id": "BetweenOLS", + "variant": "balanced", + "n_samples": 54, + "n_features": 2, + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + }, + { + "case_id": "first_difference_balanced", + "model_id": "FirstDifferenceOLS", + "variant": "balanced", + "n_samples": 54, + "n_features": 2, + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + }, + { + "case_id": "panel_entity_balanced", + "model_id": "PanelOLS", + "variant": "entity-fe-balanced", + "n_samples": 54, + "n_features": 2, + "checks": [ + "fit_statistics", + "pooling_f", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + }, + { + "case_id": "random_effects_balanced", + "model_id": "RandomEffects", + "variant": "balanced", + "n_samples": 54, + "n_features": 2, + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "random_effects_diagnostic_contract", + "backend_provenance" + ] + }, + { + "case_id": "random_effects_explicit_constant_balanced", + "model_id": "RandomEffects", + "variant": "explicit-constant-balanced", + "n_samples": 54, + "n_features": 3, + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "random_effects_diagnostic_contract", + "backend_provenance" + ] + }, + { + "case_id": "fama_macbeth_balanced", + "model_id": "FamaMacBeth", + "variant": "balanced", + "n_samples": 54, + "n_features": 2, + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + }, + { + "case_id": "panel_two_way_balanced", + "model_id": "PanelOLS", + "variant": "two-way-fe-balanced", + "n_samples": 54, + "n_features": 2, + "checks": [ + "fit_statistics", + "pooling_f", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + }, + { + "case_id": "pooled_unbalanced", + "model_id": "PooledOLS", + "variant": "unbalanced", + "n_samples": 49, + "n_features": 2, + "checks": [ + "fit_statistics", + "bp_lm", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + }, + { + "case_id": "pooled_hac_unsorted_unbalanced", + "model_id": "PooledOLS", + "variant": "unbalanced-hac-unsorted", + "n_samples": 49, + "n_features": 2, + "checks": [ + "fit_statistics", + "bp_lm", + "diagnostic_covariance", + "stage_a_inference", + "metadata_sort_alignment", + "backend_provenance" + ] + }, + { + "case_id": "between_unbalanced", + "model_id": "BetweenOLS", + "variant": "unbalanced", + "n_samples": 49, + "n_features": 2, + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + }, + { + "case_id": "first_difference_unbalanced", + "model_id": "FirstDifferenceOLS", + "variant": "unbalanced", + "n_samples": 49, + "n_features": 2, + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + }, + { + "case_id": "panel_entity_unbalanced", + "model_id": "PanelOLS", + "variant": "entity-fe-unbalanced", + "n_samples": 49, + "n_features": 2, + "checks": [ + "fit_statistics", + "pooling_f", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + }, + { + "case_id": "random_effects_unbalanced", + "model_id": "RandomEffects", + "variant": "unbalanced", + "n_samples": 49, + "n_features": 2, + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "random_effects_diagnostic_contract", + "backend_provenance" + ] + }, + { + "case_id": "random_effects_explicit_constant_unbalanced", + "model_id": "RandomEffects", + "variant": "explicit-constant-unbalanced", + "n_samples": 49, + "n_features": 3, + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "random_effects_diagnostic_contract", + "backend_provenance" + ] + }, + { + "case_id": "fama_macbeth_unbalanced", + "model_id": "FamaMacBeth", + "variant": "unbalanced", + "n_samples": 49, + "n_features": 2, + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + } ], "backend_results": { "cupy": { "status": "success", "executed_backend": "cupy", - "model_cases": {"pooled_balanced":"success","pooled_hac_unsorted_balanced":"success","between_balanced":"success","first_difference_balanced":"success","panel_entity_balanced":"success","random_effects_balanced":"success","random_effects_explicit_constant_balanced":"success","fama_macbeth_balanced":"success","panel_two_way_balanced":"success","pooled_unbalanced":"success","pooled_hac_unsorted_unbalanced":"success","between_unbalanced":"success","first_difference_unbalanced":"success","panel_entity_unbalanced":"success","random_effects_unbalanced":"success","random_effects_explicit_constant_unbalanced":"success","fama_macbeth_unbalanced":"success"}, + "model_cases": { + "pooled_balanced": "success", + "pooled_hac_unsorted_balanced": "success", + "between_balanced": "success", + "first_difference_balanced": "success", + "panel_entity_balanced": "success", + "random_effects_balanced": "success", + "random_effects_explicit_constant_balanced": "success", + "fama_macbeth_balanced": "success", + "panel_two_way_balanced": "success", + "pooled_unbalanced": "success", + "pooled_hac_unsorted_unbalanced": "success", + "between_unbalanced": "success", + "first_difference_unbalanced": "success", + "panel_entity_unbalanced": "success", + "random_effects_unbalanced": "success", + "random_effects_explicit_constant_unbalanced": "success", + "fama_macbeth_unbalanced": "success" + }, "diagnostics": { - "hausman_balanced":{"status":"success","applicable":false,"reason":"covariance difference is not positive semidefinite"}, - "hausman_explicit_re_constant_balanced":{"status":"success","applicable":false,"reason":"covariance difference is not positive semidefinite"}, - "hausman_unbalanced":{"status":"success","applicable":false,"reason":"covariance difference is not positive semidefinite"}, - "hausman_explicit_re_constant_unbalanced":{"status":"success","applicable":false,"reason":"covariance difference is not positive semidefinite"} + "hausman_balanced": { + "status": "success", + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_explicit_re_constant_balanced": { + "status": "success", + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_unbalanced": { + "status": "success", + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_explicit_re_constant_unbalanced": { + "status": "success", + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + } } }, "torch": { "status": "success", "executed_backend": "torch", - "model_cases": {"pooled_balanced":"success","pooled_hac_unsorted_balanced":"success","between_balanced":"success","first_difference_balanced":"success","panel_entity_balanced":"success","random_effects_balanced":"success","random_effects_explicit_constant_balanced":"success","fama_macbeth_balanced":"success","panel_two_way_balanced":"success","pooled_unbalanced":"success","pooled_hac_unsorted_unbalanced":"success","between_unbalanced":"success","first_difference_unbalanced":"success","panel_entity_unbalanced":"success","random_effects_unbalanced":"success","random_effects_explicit_constant_unbalanced":"success","fama_macbeth_unbalanced":"success"}, + "model_cases": { + "pooled_balanced": "success", + "pooled_hac_unsorted_balanced": "success", + "between_balanced": "success", + "first_difference_balanced": "success", + "panel_entity_balanced": "success", + "random_effects_balanced": "success", + "random_effects_explicit_constant_balanced": "success", + "fama_macbeth_balanced": "success", + "panel_two_way_balanced": "success", + "pooled_unbalanced": "success", + "pooled_hac_unsorted_unbalanced": "success", + "between_unbalanced": "success", + "first_difference_unbalanced": "success", + "panel_entity_unbalanced": "success", + "random_effects_unbalanced": "success", + "random_effects_explicit_constant_unbalanced": "success", + "fama_macbeth_unbalanced": "success" + }, "diagnostics": { - "hausman_balanced":{"status":"success","applicable":false,"reason":"covariance difference is not positive semidefinite"}, - "hausman_explicit_re_constant_balanced":{"status":"success","applicable":false,"reason":"covariance difference is not positive semidefinite"}, - "hausman_unbalanced":{"status":"success","applicable":false,"reason":"covariance difference is not positive semidefinite"}, - "hausman_explicit_re_constant_unbalanced":{"status":"success","applicable":false,"reason":"covariance difference is not positive semidefinite"} + "hausman_balanced": { + "status": "success", + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_explicit_re_constant_balanced": { + "status": "success", + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_unbalanced": { + "status": "success", + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_explicit_re_constant_unbalanced": { + "status": "success", + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + } } } } From 8386ae9f67171226a5a33fb3324f9ef891c7541e Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 13:53:53 +0800 Subject: [PATCH 115/165] benchmark: register PR122 current physical evidence --- dev/benchmarks/frontend_sources.json | 115 +++++++-------------------- 1 file changed, 29 insertions(+), 86 deletions(-) diff --git a/dev/benchmarks/frontend_sources.json b/dev/benchmarks/frontend_sources.json index 194ed50b0..5d73fff74 100644 --- a/dev/benchmarks/frontend_sources.json +++ b/dev/benchmarks/frontend_sources.json @@ -20,89 +20,32 @@ "cpu": "x86_64", "host": "wE6lDe" }, - "remote-p100-pr122-20260808": { - "label": "Tesla P100 PR #122 Panel Stage B validation — 2026-08-08", + "remote-p100-pr122-20260809": { + "label": "Tesla P100 PR #122 Panel Stage B validation — 2026-08-09", "gpu": "Tesla P100-SXM2-16GB", "cpu": "x86_64" } }, "frameworks": { - "statgpu": { - "display_name": "statgpu", - "external": false, - "backend_policy": "required" - }, - "sklearn": { - "display_name": "scikit-learn", - "external": true, - "backend_policy": "forbidden" - }, - "scipy": { - "display_name": "SciPy", - "external": true, - "backend_policy": "forbidden" - }, - "statsmodels": { - "display_name": "statsmodels", - "external": true, - "backend_policy": "forbidden" - }, - "linearmodels": { - "display_name": "linearmodels", - "external": true, - "backend_policy": "forbidden" - }, - "pygam": { - "display_name": "pyGAM", - "external": true, - "backend_policy": "forbidden" - } + "statgpu": {"display_name": "statgpu", "external": false, "backend_policy": "required"}, + "sklearn": {"display_name": "scikit-learn", "external": true, "backend_policy": "forbidden"}, + "scipy": {"display_name": "SciPy", "external": true, "backend_policy": "forbidden"}, + "statsmodels": {"display_name": "statsmodels", "external": true, "backend_policy": "forbidden"}, + "linearmodels": {"display_name": "linearmodels", "external": true, "backend_policy": "forbidden"}, + "pygam": {"display_name": "pyGAM", "external": true, "backend_policy": "forbidden"} }, "comparisons": { - "penalized-glm-perf-20260622": { - "label": "Penalized GLM performance — 2026-06-22", - "env_id": "remote-p100" - }, - "glm-solver-20260623": { - "label": "GLM solver benchmark — 2026-06-23", - "env_id": "remote-p100" - }, - "coxph-efron-20260622": { - "label": "CoxPH Efron benchmark — 2026-06-22", - "env_id": "remote-p100" - }, - "loss-functions-20260623": { - "label": "Robust, quantile, and CoxPH loss benchmark — 2026-06-23", - "env_id": "remote-p100" - }, - "ordered-inference-pr74": { - "label": "Ordered, penalized, bootstrap, and quantile inference — 2026-07-12", - "env_id": "remote-p100" - }, - "unsupervised-20260627": { - "label": "Unsupervised benchmark — 2026-06-27", - "env_id": "remote-p100" - }, - "new-modules-20260624": { - "label": "Panel, GAM, and ANOVA benchmark — 2026-06-24", - "env_id": "remote-p100" - }, - "p2-benchmark-20260617": { - "label": "Covariance and nonparametric benchmark — 2026-06-17", - "env_id": "remote-p100" - }, - "cv-benchmark-20260807": { - "label": "Cross-validation benchmark — 2026-08-07", - "env_id": "remote-p100-cv-20260807" - }, - "cv-benchmark-pr116-20260807": { - "label": "Cross-validation benchmark after PR #116 repair — 2026-08-07", - "env_id": "remote-p100-pr116-20260807" - }, - "panel-stage-b-pr122-20260808": { - "label": "Panel Stage B physical validation — PR #122 — 2026-08-08", - "env_id": "remote-p100-pr122-20260808" - } + "penalized-glm-perf-20260622": {"label": "Penalized GLM performance — 2026-06-22", "env_id": "remote-p100"}, + "glm-solver-20260623": {"label": "GLM solver benchmark — 2026-06-23", "env_id": "remote-p100"}, + "coxph-efron-20260622": {"label": "CoxPH Efron benchmark — 2026-06-22", "env_id": "remote-p100"}, + "loss-functions-20260623": {"label": "Robust, quantile, and CoxPH loss benchmark — 2026-06-23", "env_id": "remote-p100"}, + "ordered-inference-pr74": {"label": "Ordered, penalized, bootstrap, and quantile inference — 2026-07-12", "env_id": "remote-p100"}, + "unsupervised-20260627": {"label": "Unsupervised benchmark — 2026-06-27", "env_id": "remote-p100"}, + "new-modules-20260624": {"label": "Panel, GAM, and ANOVA benchmark — 2026-06-24", "env_id": "remote-p100"}, + "p2-benchmark-20260617": {"label": "Covariance and nonparametric benchmark — 2026-06-17", "env_id": "remote-p100"}, + "cv-benchmark-20260807": {"label": "Cross-validation benchmark — 2026-08-07", "env_id": "remote-p100-cv-20260807"}, + "cv-benchmark-pr116-20260807": {"label": "Cross-validation benchmark after PR #116 repair — 2026-08-07", "env_id": "remote-p100-pr116-20260807"}, + "panel-stage-b-pr122-20260809": {"label": "Panel Stage B physical validation — PR #122 — 2026-08-09", "env_id": "remote-p100-pr122-20260809"} }, "sources": [ { @@ -241,20 +184,20 @@ "provenance_note": "Physical PR #116 validation was executed on Tesla P100 from exact numerical implementation head e6e4846b06604ed53e65fc9afd9054bd5777098f. The artifact records that SHA directly; the historical pre-fix P100 source remains registered separately." }, { - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "comparison_id": "panel-stage-b-pr122-20260808", - "path": "results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260808.json", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba", + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "comparison_id": "panel-stage-b-pr122-20260809", + "path": "results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809.json", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9", "parser": "panel_stage_b_physical_validation", "parser_version": "1.0", - "env_id": "remote-p100-pr122-20260808", + "env_id": "remote-p100-pr122-20260809", "required": true, "allowed_issue_codes": [], - "source_date": "2026-08-08", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", - "raw_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", - "provenance_note": "Correctness/backend-provenance source only. Raw schema-2 artifact results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json (SHA-256 c1ba014a3b9bb0d32cbc0ca3d844ccfe767e7149189efb9ba2969f5bc1b94b31) was produced from exact clean implementation head faa95ce7fb5cb204088957fbda5544c20a06fbfc on Tesla P100-SXM2-16GB. All 17 estimator cases/backend and four Hausman diagnostics/backend passed on CuPy and Torch CUDA. No timing was collected, so the frontend must not infer timing or speedup from this source." + "source_date": "2026-08-09", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "raw_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "provenance_note": "Correctness/backend-provenance source only. Exact clean implementation head a57efcea29b0e87ecb89865c5a6902d5773812c6 passed both the full Stage-B P100 CuPy/Torch matrix and the focused disconnected two-way FE gate. Raw artifacts are results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json (Git blob 254b64776bff4e3b2b642bb4a2ae1eea25f4751c) and results/pr122_p100/panel_stage_b_disconnected_fe_gpu_validation_a57efcea.json (Git blob 3bda0b2040479ba8201e2722eb990ba086c3f3b9), committed by 72b3279d2028e8ec2af30e138e123aceb611ae8c. CuPy and Torch each passed all 17 estimator cases and four Hausman diagnostics in the full gate; the focused gate confirmed component-aware df_resid=1/effect_rank=7/incidence_components=3 and restored Torch confidence intervals to NumPy parity. No timing was collected." } ] } From e4cf6300d5a5cf092a21319aedc424d955118844 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 13:54:19 +0800 Subject: [PATCH 116/165] benchmark: refresh PR122 panel coverage source --- dev/benchmarks/benchmark_coverage_matrix.json | 259 ++---------------- 1 file changed, 20 insertions(+), 239 deletions(-) diff --git a/dev/benchmarks/benchmark_coverage_matrix.json b/dev/benchmarks/benchmark_coverage_matrix.json index 7788c9bd2..32400948e 100644 --- a/dev/benchmarks/benchmark_coverage_matrix.json +++ b/dev/benchmarks/benchmark_coverage_matrix.json @@ -2,244 +2,25 @@ "coverage_matrix_version": "1.0", "catalog_version": "2.0", "capabilities": [ - { - "capability_id": "penalized-glm-fit", - "label": "Penalized GLM fit and solver performance", - "status": "canonical_current", - "source_ids": [ - "penalized-glm-perf-20260622-e5baa1cbb516", - "glm-solver-20260623-1b6197d94d88" - ], - "representative_dimensions": [ - "family", - "loss", - "penalty", - "solver", - "backend", - "scale" - ] - }, - { - "capability_id": "coxph-breslow-efron-fit", - "label": "CoxPH Breslow and Efron fit coverage", - "status": "canonical_current", - "source_ids": [ - "coxph-efron-20260622-7192358f4c6d", - "loss-functions-20260623-f7e2d070a3b7" - ], - "representative_dimensions": [ - "ties", - "backend", - "scale", - "external_reference" - ] - }, - { - "capability_id": "robust-quantile-fit", - "label": "Robust and quantile fit coverage", - "status": "partial_canonical", - "source_ids": [ - "loss-functions-20260623-f7e2d070a3b7" - ], - "representative_dimensions": [ - "loss", - "backend", - "scale" - ], - "issue": "#102", - "disposition": "Canonical rows exist for part of the maintained matrix; Bisquare, Fair, and complete all-backend coverage remain open." - }, - { - "capability_id": "ordered-inference", - "label": "Ordered and penalized inference validation", - "status": "partial_canonical", - "source_ids": [ - "ordered-inference-20260712-c584a2bfa213" - ], - "representative_dimensions": [ - "method", - "inference_mode", - "backend", - "scale" - ], - "issue": "#104", - "disposition": "Current inference evidence is canonical; broader Ordered crossover performance remains open." - }, - { - "capability_id": "unsupervised-fit", - "label": "Unsupervised estimator fit coverage", - "status": "partial_canonical", - "source_ids": [ - "unsupervised-20260627-1ee68806e3ee" - ], - "representative_dimensions": [ - "estimator", - "backend", - "scale" - ], - "issue": "#109", - "disposition": "Current estimator-level rows are canonical; NNDescent and operation-specific timings remain open." - }, - { - "capability_id": "panel-estimation", - "label": "Panel estimation and diagnostics coverage", - "status": "partial_canonical", - "source_ids": [ - "new-modules-20260624-bcbdb676223b", - "panel-stage-b-pr122-20260808-b8caffa6f915" - ], - "representative_dimensions": [ - "estimator", - "backend", - "aligned_scale", - "physical_validation", - "diagnostics", - "inference_regression" - ], - "issue": "#108", - "disposition": "June timing rows cover aligned PanelOLS and RandomEffects. PR #122 adds canonical validation-only CuPy/Torch evidence for the 17-case Stage-B estimator matrix, four Hausman parameterizations per backend, backend provenance, and Stage-A inference regression; broader performance/covariance timing remains open." - }, - { - "capability_id": "gam-nonparametric", - "label": "GAM and nonparametric coverage", - "status": "partial_canonical", - "source_ids": [ - "new-modules-20260624-bcbdb676223b", - "p2-benchmark-20260617-e9c268d6a6f1" - ], - "representative_dimensions": [ - "method", - "backend", - "scale", - "external_reference" - ], - "issue": "#106", - "disposition": "GAM and selected P2 rows are canonical; the maintained nonparametric matrix is incomplete." - }, - { - "capability_id": "covariance-estimation", - "label": "Covariance estimator coverage", - "status": "partial_canonical", - "source_ids": [ - "p2-benchmark-20260617-e9c268d6a6f1" - ], - "representative_dimensions": [ - "estimator", - "backend", - "scale" - ], - "issue": "#106", - "disposition": "Empirical covariance evidence exists; shrinkage, robust, and graphical estimator breadth remains open." - }, - { - "capability_id": "anova", - "label": "ANOVA coverage", - "status": "partial_canonical", - "source_ids": [ - "new-modules-20260624-bcbdb676223b" - ], - "representative_dimensions": [ - "function", - "backend", - "scale" - ], - "issue": "#104", - "disposition": "Available function rows are canonical; synchronization-safe crossover evidence remains open." - }, - { - "capability_id": "distribution-api", - "label": "Distribution API operations", - "status": "current_evidence_not_canonical_ready", - "source_ids": [], - "issue": "#101", - "disposition": "June structured evidence exists but requires operation identity, provenance, timing, and parser audit before registration." - }, - { - "capability_id": "feature-selection-knockoff", - "label": "Feature Selection and Knockoff", - "status": "benchmark_data_gap", - "source_ids": [], - "issue": "#103", - "disposition": "Existing evidence predates the minimum source date and remains audit-only." - }, - { - "capability_id": "linear-glm-inference", - "label": "Systematic linear and GLM inference", - "status": "benchmark_data_gap", - "source_ids": [], - "issue": "#105", - "disposition": "A systematic coefficient, covariance, standard-error, test, interval, and likelihood matrix is not yet canonical." - }, - { - "capability_id": "penalized-coxph", - "label": "Penalized CoxPH paths", - "status": "current_evidence_not_canonical_ready", - "source_ids": [], - "issue": "#107", - "disposition": "PR79/PR80 validation evidence exists but is not treated as canonical dashboard data without a dedicated audit or rerun." - }, - { - "capability_id": "ridge-cv", - "label": "RidgeCV", - "status": "canonical_current", - "source_ids": [ - "cv-benchmark-20260807-1347184c988d" - ] - }, - { - "capability_id": "lasso-cv", - "label": "LassoCV", - "status": "canonical_current", - "source_ids": [ - "cv-benchmark-20260807-1347184c988d" - ] - }, - { - "capability_id": "elasticnet-cv", - "label": "ElasticNetCV", - "status": "canonical_current", - "source_ids": [ - "cv-benchmark-20260807-1347184c988d" - ] - }, - { - "capability_id": "logistic-regression-cv", - "label": "LogisticRegressionCV", - "status": "canonical_current", - "source_ids": [ - "cv-benchmark-20260807-1347184c988d", - "cv-benchmark-pr116-20260807-bd8d512adced" - ], - "representative_dimensions": [ - "backend", - "pre_fix_failure", - "post_fix_success", - "physical_gpu" - ] - }, - { - "capability_id": "penalized-glm-cv", - "label": "PenalizedGLM_CV", - "status": "canonical_current", - "source_ids": [ - "cv-benchmark-20260807-1347184c988d" - ] - }, - { - "capability_id": "coxph-cv", - "label": "CoxPHCV", - "status": "canonical_current", - "source_ids": [ - "cv-benchmark-20260807-1347184c988d" - ] - }, - { - "capability_id": "multiple-testing-resampling", - "label": "Multiple testing and resampling utilities", - "status": "benchmark_data_gap", - "source_ids": [], - "issue": "#109", - "disposition": "No current canonical utility-level statistical and timing matrix exists." - } + {"capability_id":"penalized-glm-fit","label":"Penalized GLM fit and solver performance","status":"canonical_current","source_ids":["penalized-glm-perf-20260622-e5baa1cbb516","glm-solver-20260623-1b6197d94d88"],"representative_dimensions":["family","loss","penalty","solver","backend","scale"]}, + {"capability_id":"coxph-breslow-efron-fit","label":"CoxPH Breslow and Efron fit coverage","status":"canonical_current","source_ids":["coxph-efron-20260622-7192358f4c6d","loss-functions-20260623-f7e2d070a3b7"],"representative_dimensions":["ties","backend","scale","external_reference"]}, + {"capability_id":"robust-quantile-fit","label":"Robust and quantile fit coverage","status":"partial_canonical","source_ids":["loss-functions-20260623-f7e2d070a3b7"],"representative_dimensions":["loss","backend","scale"],"issue":"#102","disposition":"Canonical rows exist for part of the maintained matrix; Bisquare, Fair, and complete all-backend coverage remain open."}, + {"capability_id":"ordered-inference","label":"Ordered and penalized inference validation","status":"partial_canonical","source_ids":["ordered-inference-20260712-c584a2bfa213"],"representative_dimensions":["method","inference_mode","backend","scale"],"issue":"#104","disposition":"Current inference evidence is canonical; broader Ordered crossover performance remains open."}, + {"capability_id":"unsupervised-fit","label":"Unsupervised estimator fit coverage","status":"partial_canonical","source_ids":["unsupervised-20260627-1ee68806e3ee"],"representative_dimensions":["estimator","backend","scale"],"issue":"#109","disposition":"Current estimator-level rows are canonical; NNDescent and operation-specific timings remain open."}, + {"capability_id":"panel-estimation","label":"Panel estimation and diagnostics coverage","status":"partial_canonical","source_ids":["new-modules-20260624-bcbdb676223b","panel-stage-b-pr122-20260809-a6e47b9dec9c"],"representative_dimensions":["estimator","backend","aligned_scale","physical_validation","diagnostics","inference_regression"],"issue":"#108","disposition":"June timing rows cover aligned PanelOLS and RandomEffects. PR #122 adds canonical validation-only CuPy/Torch evidence for the 17-case Stage-B estimator matrix, four Hausman parameterizations per backend, backend provenance, Stage-A inference regression, and the disconnected two-way FE df=1 physical boundary; broader performance/covariance timing remains open."}, + {"capability_id":"gam-nonparametric","label":"GAM and nonparametric coverage","status":"partial_canonical","source_ids":["new-modules-20260624-bcbdb676223b","p2-benchmark-20260617-e9c268d6a6f1"],"representative_dimensions":["method","backend","scale","external_reference"],"issue":"#106","disposition":"GAM and selected P2 rows are canonical; the maintained nonparametric matrix is incomplete."}, + {"capability_id":"covariance-estimation","label":"Covariance estimator coverage","status":"partial_canonical","source_ids":["p2-benchmark-20260617-e9c268d6a6f1"],"representative_dimensions":["estimator","backend","scale"],"issue":"#106","disposition":"Empirical covariance evidence exists; shrinkage, robust, and graphical estimator breadth remains open."}, + {"capability_id":"anova","label":"ANOVA coverage","status":"partial_canonical","source_ids":["new-modules-20260624-bcbdb676223b"],"representative_dimensions":["function","backend","scale"],"issue":"#104","disposition":"Available function rows are canonical; synchronization-safe crossover evidence remains open."}, + {"capability_id":"distribution-api","label":"Distribution API operations","status":"current_evidence_not_canonical_ready","source_ids":[],"issue":"#101","disposition":"June structured evidence exists but requires operation identity, provenance, timing, and parser audit before registration."}, + {"capability_id":"feature-selection-knockoff","label":"Feature Selection and Knockoff","status":"benchmark_data_gap","source_ids":[],"issue":"#103","disposition":"Existing evidence predates the minimum source date and remains audit-only."}, + {"capability_id":"linear-glm-inference","label":"Systematic linear and GLM inference","status":"benchmark_data_gap","source_ids":[],"issue":"#105","disposition":"A systematic coefficient, covariance, standard-error, test, interval, and likelihood matrix is not yet canonical."}, + {"capability_id":"penalized-coxph","label":"Penalized CoxPH paths","status":"current_evidence_not_canonical_ready","source_ids":[],"issue":"#107","disposition":"PR79/PR80 validation evidence exists but is not treated as canonical dashboard data without a dedicated audit or rerun."}, + {"capability_id":"ridge-cv","label":"RidgeCV","status":"canonical_current","source_ids":["cv-benchmark-20260807-1347184c988d"]}, + {"capability_id":"lasso-cv","label":"LassoCV","status":"canonical_current","source_ids":["cv-benchmark-20260807-1347184c988d"]}, + {"capability_id":"elasticnet-cv","label":"ElasticNetCV","status":"canonical_current","source_ids":["cv-benchmark-20260807-1347184c988d"]}, + {"capability_id":"logistic-regression-cv","label":"LogisticRegressionCV","status":"canonical_current","source_ids":["cv-benchmark-20260807-1347184c988d","cv-benchmark-pr116-20260807-bd8d512adced"],"representative_dimensions":["backend","pre_fix_failure","post_fix_success","physical_gpu"]}, + {"capability_id":"penalized-glm-cv","label":"PenalizedGLM_CV","status":"canonical_current","source_ids":["cv-benchmark-20260807-1347184c988d"]}, + {"capability_id":"coxph-cv","label":"CoxPHCV","status":"canonical_current","source_ids":["cv-benchmark-20260807-1347184c988d"]}, + {"capability_id":"multiple-testing-resampling","label":"Multiple testing and resampling utilities","status":"benchmark_data_gap","source_ids":[],"issue":"#109","disposition":"No current canonical utility-level statistical and timing matrix exists."} ] } From 6babb2727682652a68261128a3c2ba7cc525e592 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 13:54:32 +0800 Subject: [PATCH 117/165] benchmark: retire superseded PR122 canonical source --- .../panel_stage_b_pr122_p100_20260808.json | 459 ------------------ 1 file changed, 459 deletions(-) delete mode 100644 results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260808.json diff --git a/results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260808.json b/results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260808.json deleted file mode 100644 index 38ed1ef01..000000000 --- a/results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260808.json +++ /dev/null @@ -1,459 +0,0 @@ -{ - "method": "Panel Tier-1 Stage B physical GPU validation", - "source_schema_version": "1.0", - "source_date": "2026-08-08", - "git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", - "working_tree_clean": true, - "status": "success", - "raw_artifact": { - "path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "c1ba014a3b9bb0d32cbc0ca3d844ccfe767e7149189efb9ba2969f5bc1b94b31", - "repository_commit": "806789ac7c1f71d7c91656b86dad91ab0f103582", - "generated_at": "2026-08-08T14:49:33.405711Z", - "schema_version": 2 - }, - "environment": { - "env_id": "remote-p100-pr122-20260808", - "gpu": "Tesla P100-SXM2-16GB", - "cpu": "x86_64", - "platform": "Linux-3.10.0-1062.el7.x86_64-x86_64-with-glibc2.31", - "python": "3.9.16", - "packages": { - "statgpu": "0.2.4", - "numpy": "1.24.2", - "scipy": "1.10.1", - "cupy": null, - "torch": "2.0.0" - }, - "available_backends": [ - "cupy", - "torch" - ] - }, - "protocol": { - "runner": "dev/benchmarks/validate_panel_stage_b_gpu.py", - "runner_schema_version": 2, - "reference_backend": "numpy", - "dtype": "float64", - "timing_collected": false, - "failure_policy": "fail_on_backend_mismatch_or_precision_regression", - "rtol": 5e-06, - "atol": 5e-07 - }, - "backend_times": { - "numpy": null, - "cupy": null, - "torch": null - }, - "external_baseline": { - "name": "statgpu NumPy reference", - "time": null, - "version": null - }, - "precision_vs_external": {}, - "convergence_status": {}, - "backend_precision": { - "cupy": "pass", - "torch": "pass" - }, - "precision_summary": { - "max_coef_abs_difference": { - "cupy": 5.551115123125783e-16, - "torch": 6.661338147750939e-16 - }, - "explicit_constant_re_max_coef_abs_difference": { - "cupy": 9.71445146547012e-17, - "torch": 2.220446049250313e-16 - }, - "random_effects_diagnostic_contract_max_difference": { - "cupy": 0.0, - "torch": 0.0 - } - }, - "compatibility_matrix": { - "cupy": { - "model_cases": "17/17", - "diagnostics": "4/4", - "executed_backend": "cupy", - "cpu_fallback": false - }, - "torch": { - "model_cases": "17/17", - "diagnostics": "4/4", - "executed_backend": "torch", - "cpu_fallback": false - } - }, - "cv_matrix": {}, - "inference_matrix": { - "status": "pass", - "fields": [ - "coef", - "bse", - "tvalues", - "pvalues", - "conf_int", - "nobs", - "df_resid" - ], - "reference": "statgpu NumPy", - "reported_precision": "all checks within validator tolerances; coefficient differences are at machine-epsilon scale" - }, - "threshold_source": { - "stage_b": "validator-defined backend parity tolerances", - "stage_a_regression": "validator-defined inference parity tolerances" - }, - "objective_scaling": null, - "penalty_scale_mapping": null, - "cpu_vs_external": null, - "gpu_vs_cpu": null, - "crossover_n": null, - "target_scale_source": "correctness-only physical validation; no performance target", - "optimization_notes": [], - "validation_tier": "remote-full", - "schema_status": "ok", - "timing_scope": { - "collected": false, - "reason": "Correctness/backend-provenance validation only; no benchmark timing was measured." - }, - "reproducibility": { - "exact_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", - "working_tree_clean": true, - "runner": "dev/benchmarks/validate_panel_stage_b_gpu.py", - "raw_artifact_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "raw_artifact_sha256": "c1ba014a3b9bb0d32cbc0ca3d844ccfe767e7149189efb9ba2969f5bc1b94b31" - }, - "uncovered_reasons": [ - "Performance timing was not collected by this correctness-only physical validation and must not be inferred from this artifact.", - "All standard and explicit-RE-constant Hausman validation datasets produced materially indefinite covariance differences; applicability/reason parity against NumPy, not a fabricated statistic, is recorded.", - "The runner could not resolve an installed CuPy distribution version through importlib.metadata, so the canonical source records the CuPy package version as null while preserving executed_backend='cupy' as physical backend provenance." - ], - "case_catalog": [ - { - "case_id": "pooled_balanced", - "model_id": "PooledOLS", - "variant": "balanced", - "n_samples": 54, - "n_features": 2, - "checks": [ - "fit_statistics", - "bp_lm", - "diagnostic_covariance", - "stage_a_inference", - "backend_provenance" - ] - }, - { - "case_id": "pooled_hac_unsorted_balanced", - "model_id": "PooledOLS", - "variant": "balanced-hac-unsorted", - "n_samples": 54, - "n_features": 2, - "checks": [ - "fit_statistics", - "bp_lm", - "diagnostic_covariance", - "stage_a_inference", - "metadata_sort_alignment", - "backend_provenance" - ] - }, - { - "case_id": "between_balanced", - "model_id": "BetweenOLS", - "variant": "balanced", - "n_samples": 54, - "n_features": 2, - "checks": [ - "fit_statistics", - "diagnostic_covariance", - "stage_a_inference", - "backend_provenance" - ] - }, - { - "case_id": "first_difference_balanced", - "model_id": "FirstDifferenceOLS", - "variant": "balanced", - "n_samples": 54, - "n_features": 2, - "checks": [ - "fit_statistics", - "diagnostic_covariance", - "stage_a_inference", - "backend_provenance" - ] - }, - { - "case_id": "panel_entity_balanced", - "model_id": "PanelOLS", - "variant": "entity-fe-balanced", - "n_samples": 54, - "n_features": 2, - "checks": [ - "fit_statistics", - "pooling_f", - "diagnostic_covariance", - "stage_a_inference", - "backend_provenance" - ] - }, - { - "case_id": "random_effects_balanced", - "model_id": "RandomEffects", - "variant": "balanced", - "n_samples": 54, - "n_features": 2, - "checks": [ - "fit_statistics", - "diagnostic_covariance", - "stage_a_inference", - "random_effects_diagnostic_contract", - "backend_provenance" - ] - }, - { - "case_id": "random_effects_explicit_constant_balanced", - "model_id": "RandomEffects", - "variant": "explicit-constant-balanced", - "n_samples": 54, - "n_features": 3, - "checks": [ - "fit_statistics", - "diagnostic_covariance", - "stage_a_inference", - "random_effects_diagnostic_contract", - "backend_provenance" - ] - }, - { - "case_id": "fama_macbeth_balanced", - "model_id": "FamaMacBeth", - "variant": "balanced", - "n_samples": 54, - "n_features": 2, - "checks": [ - "fit_statistics", - "diagnostic_covariance", - "stage_a_inference", - "backend_provenance" - ] - }, - { - "case_id": "panel_two_way_balanced", - "model_id": "PanelOLS", - "variant": "two-way-fe-balanced", - "n_samples": 54, - "n_features": 2, - "checks": [ - "fit_statistics", - "pooling_f", - "diagnostic_covariance", - "stage_a_inference", - "backend_provenance" - ] - }, - { - "case_id": "pooled_unbalanced", - "model_id": "PooledOLS", - "variant": "unbalanced", - "n_samples": 49, - "n_features": 2, - "checks": [ - "fit_statistics", - "bp_lm", - "diagnostic_covariance", - "stage_a_inference", - "backend_provenance" - ] - }, - { - "case_id": "pooled_hac_unsorted_unbalanced", - "model_id": "PooledOLS", - "variant": "unbalanced-hac-unsorted", - "n_samples": 49, - "n_features": 2, - "checks": [ - "fit_statistics", - "bp_lm", - "diagnostic_covariance", - "stage_a_inference", - "metadata_sort_alignment", - "backend_provenance" - ] - }, - { - "case_id": "between_unbalanced", - "model_id": "BetweenOLS", - "variant": "unbalanced", - "n_samples": 49, - "n_features": 2, - "checks": [ - "fit_statistics", - "diagnostic_covariance", - "stage_a_inference", - "backend_provenance" - ] - }, - { - "case_id": "first_difference_unbalanced", - "model_id": "FirstDifferenceOLS", - "variant": "unbalanced", - "n_samples": 49, - "n_features": 2, - "checks": [ - "fit_statistics", - "diagnostic_covariance", - "stage_a_inference", - "backend_provenance" - ] - }, - { - "case_id": "panel_entity_unbalanced", - "model_id": "PanelOLS", - "variant": "entity-fe-unbalanced", - "n_samples": 49, - "n_features": 2, - "checks": [ - "fit_statistics", - "pooling_f", - "diagnostic_covariance", - "stage_a_inference", - "backend_provenance" - ] - }, - { - "case_id": "random_effects_unbalanced", - "model_id": "RandomEffects", - "variant": "unbalanced", - "n_samples": 49, - "n_features": 2, - "checks": [ - "fit_statistics", - "diagnostic_covariance", - "stage_a_inference", - "random_effects_diagnostic_contract", - "backend_provenance" - ] - }, - { - "case_id": "random_effects_explicit_constant_unbalanced", - "model_id": "RandomEffects", - "variant": "explicit-constant-unbalanced", - "n_samples": 49, - "n_features": 3, - "checks": [ - "fit_statistics", - "diagnostic_covariance", - "stage_a_inference", - "random_effects_diagnostic_contract", - "backend_provenance" - ] - }, - { - "case_id": "fama_macbeth_unbalanced", - "model_id": "FamaMacBeth", - "variant": "unbalanced", - "n_samples": 49, - "n_features": 2, - "checks": [ - "fit_statistics", - "diagnostic_covariance", - "stage_a_inference", - "backend_provenance" - ] - } - ], - "backend_results": { - "cupy": { - "status": "success", - "executed_backend": "cupy", - "model_cases": { - "pooled_balanced": "success", - "pooled_hac_unsorted_balanced": "success", - "between_balanced": "success", - "first_difference_balanced": "success", - "panel_entity_balanced": "success", - "random_effects_balanced": "success", - "random_effects_explicit_constant_balanced": "success", - "fama_macbeth_balanced": "success", - "panel_two_way_balanced": "success", - "pooled_unbalanced": "success", - "pooled_hac_unsorted_unbalanced": "success", - "between_unbalanced": "success", - "first_difference_unbalanced": "success", - "panel_entity_unbalanced": "success", - "random_effects_unbalanced": "success", - "random_effects_explicit_constant_unbalanced": "success", - "fama_macbeth_unbalanced": "success" - }, - "diagnostics": { - "hausman_balanced": { - "status": "success", - "applicable": false, - "reason": "covariance difference is not positive semidefinite" - }, - "hausman_explicit_re_constant_balanced": { - "status": "success", - "applicable": false, - "reason": "covariance difference is not positive semidefinite" - }, - "hausman_unbalanced": { - "status": "success", - "applicable": false, - "reason": "covariance difference is not positive semidefinite" - }, - "hausman_explicit_re_constant_unbalanced": { - "status": "success", - "applicable": false, - "reason": "covariance difference is not positive semidefinite" - } - } - }, - "torch": { - "status": "success", - "executed_backend": "torch", - "model_cases": { - "pooled_balanced": "success", - "pooled_hac_unsorted_balanced": "success", - "between_balanced": "success", - "first_difference_balanced": "success", - "panel_entity_balanced": "success", - "random_effects_balanced": "success", - "random_effects_explicit_constant_balanced": "success", - "fama_macbeth_balanced": "success", - "panel_two_way_balanced": "success", - "pooled_unbalanced": "success", - "pooled_hac_unsorted_unbalanced": "success", - "between_unbalanced": "success", - "first_difference_unbalanced": "success", - "panel_entity_unbalanced": "success", - "random_effects_unbalanced": "success", - "random_effects_explicit_constant_unbalanced": "success", - "fama_macbeth_unbalanced": "success" - }, - "diagnostics": { - "hausman_balanced": { - "status": "success", - "applicable": false, - "reason": "covariance difference is not positive semidefinite" - }, - "hausman_explicit_re_constant_balanced": { - "status": "success", - "applicable": false, - "reason": "covariance difference is not positive semidefinite" - }, - "hausman_unbalanced": { - "status": "success", - "applicable": false, - "reason": "covariance difference is not positive semidefinite" - }, - "hausman_explicit_re_constant_unbalanced": { - "status": "success", - "applicable": false, - "reason": "covariance difference is not positive semidefinite" - } - } - } - } -} From 725f4c2b0cbfca0a60549ae6ec0d8ff3bc95eb29 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 13:55:25 +0800 Subject: [PATCH 118/165] docs: record final PR122 physical GPU acceptance --- dev/reviews/pr122_physical_gpu_validation.md | 118 +++++++++---------- 1 file changed, 58 insertions(+), 60 deletions(-) diff --git a/dev/reviews/pr122_physical_gpu_validation.md b/dev/reviews/pr122_physical_gpu_validation.md index 7e2a9fbd8..10efca39b 100644 --- a/dev/reviews/pr122_physical_gpu_validation.md +++ b/dev/reviews/pr122_physical_gpu_validation.md @@ -1,89 +1,87 @@ # PR #122 Panel Stage B physical GPU validation -## Current applicability status +## Final acceptance status -The physical artifact documented below remains an immutable, successful record for exact implementation head `faa95ce7fb5cb204088957fbda5544c20a06fbfc`. It is **not** current exact-head acceptance for the latest PR implementation. +Panel Tier-1 Stage B has current physical GPU acceptance for exact numerical implementation head `a57efcea29b0e87ecb89865c5a6902d5773812c6`. -After the PR was promoted to Ready for review, a fresh review identified that disconnected two-way `PanelOLS` fits could still be rejected by the legacy residual-df feasibility gate before the already-correct `N + T - C` diagnostic rank was applied. Commit `ac2f04a15c67d0b5db31b521a2a7581759abb9e8` changes `statgpu/panel/_fixed_effects.py` so component-aware rank is computed before fit feasibility and is used when the legacy df is nonpositive but the rank-consistent df remains positive. Because this is a statistical implementation change after the physically validated head, repository policy requires a new exact-head CuPy/Torch physical validation before PR #122 can return to merge-ready status. +Both maintained P100 gates were executed from that exact implementation with a clean working tree and completed successfully on CuPy and Torch CUDA: -Accordingly: +1. `dev/benchmarks/validate_panel_stage_b_gpu.py` +2. `dev/benchmarks/validate_panel_stage_b_disconnected_fe_gpu.py` -- the `faa95ce7...` artifact remains valid historical evidence for that exact implementation; -- the canonical frontend source derived from it remains provenance-correct for measurement SHA `faa95ce7...`, but must not be interpreted as validation of the newer FE implementation; -- current PR status is `PARTIAL_REMOTE_PENDING` until a clean exact-head physical run passes and its evidence is audited/promoted; -- PR #122 is intentionally kept Draft while that gate is pending. +The raw outputs were committed unchanged in repository commit `72b3279d2028e8ec2af30e138e123aceb611ae8c`. The compare from `a57efcea...` to `72b3279d...` contains only those two JSON evidence files; no production, test, workflow, or validation-runner code changed. -Validated implementation head: `faa95ce7fb5cb204088957fbda5544c20a06fbfc`. +## Raw evidence -Raw machine-readable evidence: +Full Stage-B matrix: -- artifact: `results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json` -- raw SHA-256: `c1ba014a3b9bb0d32cbc0ca3d844ccfe767e7149189efb9ba2969f5bc1b94b31` -- repository commit carrying the immutable raw artifact: `806789ac7c1f71d7c91656b86dad91ab0f103582` -- runner schema: 2 -- top-level `git_sha`: `faa95ce7fb5cb204088957fbda5544c20a06fbfc` +- path: `results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json` +- Git blob: `254b64776bff4e3b2b642bb4a2ae1eea25f4751c` +- schema version: 2 +- top-level `git_sha`: `a57efcea29b0e87ecb89865c5a6902d5773812c6` - `working_tree_clean = true` - `status = success` +- CuPy: all 17 estimator cases and all four Hausman diagnostics succeeded with the requested CuPy backend +- Torch: all 17 estimator cases and all four Hausman diagnostics succeeded with the requested Torch backend +- no timing or speedup measurement was collected -Canonical frontend evidence: +Focused disconnected two-way FE gate: -- source: `results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260808.json` -- canonical SHA-256: `b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba` -- frontend source id: `panel-stage-b-pr122-20260808-b8caffa6f915` -- parser: `panel_stage_b_physical_validation` v1.0 -- evidence type: validation/correctness/backend provenance only; no timing or speedup is inferred from this source. +- path: `results/pr122_p100/panel_stage_b_disconnected_fe_gpu_validation_a57efcea.json` +- Git blob: `3bda0b2040479ba8201e2722eb990ba086c3f3b9` +- schema version: 1 +- top-level `git_sha`: `a57efcea29b0e87ecb89865c5a6902d5773812c6` +- `working_tree_clean = true` +- `status = success` +- fixture: two disconnected 2x2 incidence blocks plus one singleton +- `nobs = 9` +- legacy residual df = 0 +- component-aware/public residual df = 1 +- effect rank = 7 +- `rank_x = 1` +- incidence components = 3 +- CuPy and Torch both executed on the requested backend and matched NumPy within the validator tolerances -Environment reported by the physical run: +The NumPy reference confidence interval for the one-slope fixture is approximately `[-4.853102368087349, 7.853102368087349]`. CuPy and Torch both return approximately `[-4.853102368087348, 7.853102368087348]`; the recorded maximum absolute CI difference is `8.881784197001252e-16` for each GPU backend. -- NVIDIA Tesla P100-SXM2-16GB -- Python 3.9.16 -- statgpu 0.2.4 -- NumPy 1.24.2 -- SciPy 1.10.1 -- PyTorch 2.0.0 -- CuPy CUDA execution is proven by `executed_backend = cupy`; the runner's `importlib.metadata` package-version lookup returned `null`, so the canonical evidence deliberately does not fabricate a CuPy version. +This focused result closes the physical regression that previously produced a Torch interval of roughly `[-49998.5, 50001.5]` at residual df 1. The repaired panel inference uses the exact identity `Student-t(df=1) == standard Cauchy`; the successful P100 rerun confirms the corrected boundary on physical Torch CUDA as well as CuPy. -CuPy acceptance: +## Environment -- 17/17 estimator cases succeeded with `executed_backend = cupy`; -- all four Hausman diagnostic cases succeeded; -- balanced and unbalanced PooledOLS, unsorted-time HAC PooledOLS, BetweenOLS, FirstDifferenceOLS, one-way PanelOLS, RandomEffects, explicit-constant RandomEffects, and FamaMacBeth succeeded; -- balanced two-way PanelOLS succeeded; -- no CPU fallback was observed. +Both artifacts report: -Torch acceptance: +- GPU: Tesla P100-SXM2-16GB +- Python: 3.9.16 +- statgpu: 0.2.4 +- NumPy: 1.24.2 +- SciPy: 1.10.1 +- PyTorch: 2.0.0 -- 17/17 estimator cases succeeded with `executed_backend = torch`; -- all four Hausman diagnostic cases succeeded; -- no silent CPU fallback was observed. +The runner could not resolve the installed CuPy distribution version through `importlib.metadata`, so the artifact records that package field as `null`. Physical CuPy execution is instead established by the per-backend `executed_backend = "cupy"` provenance checks. -Explicit-constant RandomEffects repair acceptance: +## Canonical frontend evidence -- `random_effects_explicit_constant_balanced` succeeded on CuPy and Torch; -- `random_effects_explicit_constant_unbalanced` succeeded on CuPy and Torch; -- the largest explicit-constant RE coefficient difference versus NumPy was `2.220446049250313e-16`; -- `random_effects_diagnostic_contract` had zero backend-vs-NumPy difference for every RE case. +Current canonical validation source: + +- path: `results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809.json` +- canonical SHA-256: `a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9` +- source id: `panel-stage-b-pr122-20260809-a6e47b9dec9c` +- measurement implementation SHA: `a57efcea29b0e87ecb89865c5a6902d5773812c6` +- parser: `panel_stage_b_physical_validation` v1.0 +- validation-only evidence; no timing or speedup is inferred -Hausman acceptance: +The source registers the full 17-case matrix and four Hausman parameterizations per backend, producing 42 validation rows. It also records the focused disconnected-FE gate as supporting provenance rather than inventing timing rows for it. -- `hausman_balanced`, `hausman_unbalanced`, `hausman_explicit_re_constant_balanced`, and `hausman_explicit_re_constant_unbalanced` all matched NumPy on both GPU backends; -- all generated validation datasets produced a materially indefinite covariance difference, so the test was consistently structured-inapplicable with reason `covariance difference is not positive semidefinite` rather than reporting a fabricated statistic; -- the frontend parser distinguishes standard and RE-explicit-constant Hausman parameterizations so the two cases do not collapse to indistinguishable dashboard variants. +The earlier canonical source measured at `faa95ce7fb5cb204088957fbda5544c20a06fbfc` is historical evidence for that older implementation and is no longer the current dashboard source. Its immutable raw artifact remains preserved in `results/pr122_p100/`. -Stage-B checks passed for the maintained model matrix: +## Applicability after evidence-only commits -- parameter-based within/between/overall/adjusted R-squared; -- classical model F statistic and p-value where defined; -- PooledOLS Breusch-Pagan LM statistic/p-value; -- fixed-effects pooling F statistic/p-value; -- FE-vs-RE Hausman applicability/reason parity; -- diagnostic covariance matrices; -- RandomEffects explicit-constant diagnostic metadata. +The physical acceptance is anchored to the exact numerical implementation `a57efcea...`. Subsequent commits may add or promote raw evidence, canonical metadata, generated benchmark assets, and review documentation without invalidating the numerical measurement, provided a repository compare confirms that no production, test, workflow, or physical-runner implementation changed after `a57efcea...`. -Stage-A regression checks also passed for `coef`, `bse`, `tvalues`, `pvalues`, `conf_int`, `nobs`, and `df_resid`. All fields stayed within the runner's `rtol=5e-6`, `atol=5e-7` parity contract; coefficient differences remained at machine-epsilon scale. +If any such implementation file changes later, a new exact-head physical validation is required before PR #122 can again be considered physically accepted. -The canonical frontend source represents 42 validation-only runs: 34 estimator/backend rows plus eight Hausman/backend rows. It deliberately contains no timing or speedup metrics. +## Acceptance conclusion -The dedicated identity-overhead benchmark remains accepted from the immediately preceding implementation candidate because the `faa95ce7...` repair only changes the explicit-constant RandomEffects auxiliary-within branch, while the benchmark exercises PanelOLS and no-explicit-constant RandomEffects. Its measured digest/no-digest ratios remained approximately 1.04x-1.29x over the maintained target scales. +**PHYSICAL_GPU_ACCEPTED** for Panel Tier-1 Stage B numerical implementation `a57efcea29b0e87ecb89865c5a6902d5773812c6`. -For the validated `faa95ce7...` implementation, this exact-head raw artifact superseded the earlier `636988...` canonical physical record and the failed `9c78bf66...` correctness attempt. Canonical promotion for that measurement was complete: generated frontend assets were refreshed, exact-head hosted staleness/e2e/production QA passed on the evidence head, and the stale-evidence review thread was resolved. The later disconnected-FE feasibility repair now requires a new exact-head physical validation before current-code acceptance can be promoted again. +The remaining PR lifecycle work is evidence/frontend staleness synchronization, hosted final-head validation, and the normal review-thread/fresh-review process. No additional P100 rerun is required unless numerical or validation-runner code changes. From af42c47f5b03389743dc8d03d59c04e93bf915e0 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 13:56:40 +0800 Subject: [PATCH 119/165] test: refresh PR122 canonical physical source contract --- .../test_panel_stage_b_frontend_source.py | 74 +++++++++++++++---- 1 file changed, 59 insertions(+), 15 deletions(-) diff --git a/dev/tests/test_panel_stage_b_frontend_source.py b/dev/tests/test_panel_stage_b_frontend_source.py index 86eb1ab70..98a7a2e49 100644 --- a/dev/tests/test_panel_stage_b_frontend_source.py +++ b/dev/tests/test_panel_stage_b_frontend_source.py @@ -1,5 +1,6 @@ from __future__ import annotations +import hashlib import json import sys from pathlib import Path @@ -12,28 +13,46 @@ REPO_ROOT / "results" / "benchmark_frontend_sources" - / "panel_stage_b_pr122_p100_20260808.json" + / "panel_stage_b_pr122_p100_20260809.json" ) RAW_SOURCE_PATH = ( REPO_ROOT / "results" / "pr122_p100" - / "panel_stage_b_gpu_validation_faa95ce7.json" + / "panel_stage_b_gpu_validation_a57efcea.json" ) -EXPECTED_SHA256 = "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" -RAW_EXPECTED_SHA256 = "c1ba014a3b9bb0d32cbc0ca3d844ccfe767e7149189efb9ba2969f5bc1b94b31" -SOURCE_ID = "panel-stage-b-pr122-20260808-b8caffa6f915" -MEASUREMENT_SHA = "faa95ce7fb5cb204088957fbda5544c20a06fbfc" +FOCUSED_SOURCE_PATH = ( + REPO_ROOT + / "results" + / "pr122_p100" + / "panel_stage_b_disconnected_fe_gpu_validation_a57efcea.json" +) +EXPECTED_SHA256 = "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" +RAW_EXPECTED_BLOB_SHA = "254b64776bff4e3b2b642bb4a2ae1eea25f4751c" +FOCUSED_EXPECTED_BLOB_SHA = "3bda0b2040479ba8201e2722eb990ba086c3f3b9" +SOURCE_ID = "panel-stage-b-pr122-20260809-a6e47b9dec9c" +MEASUREMENT_SHA = "a57efcea29b0e87ecb89865c5a6902d5773812c6" +ARTIFACT_COMMIT = "72b3279d2028e8ec2af30e138e123aceb611ae8c" +ENV_ID = "remote-p100-pr122-20260809" + + +def _git_blob_sha(path: Path) -> str: + raw = path.read_bytes() + header = f"blob {len(raw)}\0".encode("ascii") + return hashlib.sha1(header + raw).hexdigest() def test_pr122_physical_source_contract_and_hash() -> None: from dev.benchmarks.frontend_data.canonical import source_sha256 data = json.loads(SOURCE_PATH.read_text(encoding="utf-8")) + focused = json.loads(FOCUSED_SOURCE_PATH.read_text(encoding="utf-8")) + assert source_sha256(SOURCE_PATH) == EXPECTED_SHA256 - assert source_sha256(RAW_SOURCE_PATH) == RAW_EXPECTED_SHA256 + assert _git_blob_sha(RAW_SOURCE_PATH) == RAW_EXPECTED_BLOB_SHA + assert _git_blob_sha(FOCUSED_SOURCE_PATH) == FOCUSED_EXPECTED_BLOB_SHA assert data["source_schema_version"] == "1.0" - assert data["source_date"] == "2026-08-08" + assert data["source_date"] == "2026-08-09" assert data["git_sha"] == MEASUREMENT_SHA assert data["working_tree_clean"] is True assert data["status"] == "success" @@ -47,8 +66,32 @@ def test_pr122_physical_source_contract_and_hash() -> None: assert data["compatibility_matrix"]["torch"]["diagnostics"] == "4/4" assert data["compatibility_matrix"]["cupy"]["cpu_fallback"] is False assert data["compatibility_matrix"]["torch"]["cpu_fallback"] is False - assert data["raw_artifact"]["path"] == str(RAW_SOURCE_PATH.relative_to(REPO_ROOT)) - assert data["raw_artifact"]["sha256"] == RAW_EXPECTED_SHA256 + assert data["compatibility_matrix"]["cupy"]["disconnected_fe"] == "pass" + assert data["compatibility_matrix"]["torch"]["disconnected_fe"] == "pass" + + raw = data["raw_artifact"] + assert raw["path"] == str(RAW_SOURCE_PATH.relative_to(REPO_ROOT)) + assert raw["repository_commit"] == ARTIFACT_COMMIT + assert raw["git_blob_sha"] == RAW_EXPECTED_BLOB_SHA + + focused_meta = data["focused_artifact"] + assert focused_meta["path"] == str(FOCUSED_SOURCE_PATH.relative_to(REPO_ROOT)) + assert focused_meta["repository_commit"] == ARTIFACT_COMMIT + assert focused_meta["git_blob_sha"] == FOCUSED_EXPECTED_BLOB_SHA + assert focused_meta["status"] == "success" + + assert focused["git_sha"] == MEASUREMENT_SHA + assert focused["working_tree_clean"] is True + assert focused["status"] == "success" + assert focused["reference"]["legacy_df_resid"] == 0 + assert focused["reference"]["df_resid"] == 1 + assert focused["reference"]["diagnostic_df"]["effect_rank"] == 7 + assert focused["reference"]["diagnostic_df"]["incidence_components"] == 3 + assert focused["backend_results"]["cupy"]["executed_backend"] == "cupy" + assert focused["backend_results"]["torch"]["executed_backend"] == "torch" + assert focused["backend_results"]["cupy"]["status"] == "success" + assert focused["backend_results"]["torch"]["status"] == "success" + assert focused["backend_results"]["torch"]["differences_vs_numpy"]["conf_int"] < 1e-12 assert data["environment"]["gpu"] == "Tesla P100-SXM2-16GB" assert data["environment"]["packages"]["cupy"] is None @@ -59,7 +102,7 @@ def test_pr122_parser_emits_validation_only_frontend_runs() -> None: ) runs, models, warnings = parse_panel_stage_b_physical_validation( - SOURCE_PATH, "remote-p100-pr122-20260808" + SOURCE_PATH, ENV_ID ) assert warnings == [] @@ -124,13 +167,14 @@ def test_pr122_parser_is_registered_in_manifest() -> None: manifest = load_manifest(REPO_ROOT) assert manifest is not None entry = next(source for source in manifest["sources"] if source["source_id"] == SOURCE_ID) - assert entry["path"] == ( - "results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260808.json" - ) + assert entry["path"] == str(SOURCE_PATH.relative_to(REPO_ROOT)) assert entry["original_path"] == str(RAW_SOURCE_PATH.relative_to(REPO_ROOT)) assert entry["sha256"] == EXPECTED_SHA256 assert entry["parser"] == "panel_stage_b_physical_validation" assert entry["parser_version"] == "1.0" + assert entry["env_id"] == ENV_ID + assert entry["source_date"] == "2026-08-09" assert entry["measurement_git_sha"] == MEASUREMENT_SHA assert entry["raw_git_sha"] == MEASUREMENT_SHA - assert RAW_EXPECTED_SHA256 in entry["provenance_note"] + assert RAW_EXPECTED_BLOB_SHA in entry["provenance_note"] + assert FOCUSED_EXPECTED_BLOB_SHA in entry["provenance_note"] From 52a9a86498065d4ab075391f045e84a0a5daf3cc Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 13:57:01 +0800 Subject: [PATCH 120/165] test: refresh PR122 panel coverage identity --- dev/tests/test_benchmark_catalog.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dev/tests/test_benchmark_catalog.py b/dev/tests/test_benchmark_catalog.py index f16263bad..209c57645 100644 --- a/dev/tests/test_benchmark_catalog.py +++ b/dev/tests/test_benchmark_catalog.py @@ -110,7 +110,7 @@ def test_coverage_matrix_is_referentially_complete(coverage_matrix, manifest): ] assert rows["panel-estimation"]["source_ids"] == [ "new-modules-20260624-bcbdb676223b", - "panel-stage-b-pr122-20260808-b8caffa6f915", + "panel-stage-b-pr122-20260809-a6e47b9dec9c", ] assert rows["distribution-api"]["issue"] == "#101" assert rows["feature-selection-knockoff"]["issue"] == "#103" From 659abb8873437e4fd4f71f17a66da6a5e2a3a90c Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 13:57:52 +0800 Subject: [PATCH 121/165] test: publish current PR122 physical source identity --- dev/tests/test_frontend_domain_coverage.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/dev/tests/test_frontend_domain_coverage.py b/dev/tests/test_frontend_domain_coverage.py index ff7808b04..7b0f7b2d1 100644 --- a/dev/tests/test_frontend_domain_coverage.py +++ b/dev/tests/test_frontend_domain_coverage.py @@ -303,7 +303,7 @@ def test_panel_stage_b_physical_validation_is_published_without_timing(canonical run for run in output["runs"] if run["source"]["source_id"] - == "panel-stage-b-pr122-20260808-b8caffa6f915" + == "panel-stage-b-pr122-20260809-a6e47b9dec9c" ] assert len(rows) == 42 assert {run["backend"] for run in rows} == {"cupy", "torch"} @@ -320,7 +320,7 @@ def test_panel_stage_b_physical_validation_is_published_without_timing(canonical assert all("speedup" not in run["metrics"] for run in rows) assert all( run["parameters"]["measurement_git_sha"] - == "faa95ce7fb5cb204088957fbda5544c20a06fbfc" + == "a57efcea29b0e87ecb89865c5a6902d5773812c6" for run in rows ) @@ -437,4 +437,4 @@ def test_domain_models_are_present(canonical_output): "WelchANOVA", "TukeyHSD", "BonferroniCorrection", - } <= model_ids \ No newline at end of file + } <= model_ids From fd68a6bc6267e939f8d9a7deb7354d61b26c4ef1 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 14:03:51 +0800 Subject: [PATCH 122/165] test: point PR122 review regressions at current evidence --- dev/tests/test_panel_stage_b_ready_review_regressions.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dev/tests/test_panel_stage_b_ready_review_regressions.py b/dev/tests/test_panel_stage_b_ready_review_regressions.py index 5f8a845ce..a3814f5da 100644 --- a/dev/tests/test_panel_stage_b_ready_review_regressions.py +++ b/dev/tests/test_panel_stage_b_ready_review_regressions.py @@ -19,7 +19,7 @@ REPO_ROOT / "results" / "benchmark_frontend_sources" - / "panel_stage_b_pr122_p100_20260808.json" + / "panel_stage_b_pr122_p100_20260809.json" ) From 9640bdd72235d2d9cad1bd663bd20669afb5e81e Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 14:04:20 +0800 Subject: [PATCH 123/165] docs: clarify PR122 physical evidence applicability --- dev/reviews/pr122_physical_gpu_validation.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/dev/reviews/pr122_physical_gpu_validation.md b/dev/reviews/pr122_physical_gpu_validation.md index 10efca39b..2f48355b4 100644 --- a/dev/reviews/pr122_physical_gpu_validation.md +++ b/dev/reviews/pr122_physical_gpu_validation.md @@ -9,7 +9,7 @@ Both maintained P100 gates were executed from that exact implementation with a c 1. `dev/benchmarks/validate_panel_stage_b_gpu.py` 2. `dev/benchmarks/validate_panel_stage_b_disconnected_fe_gpu.py` -The raw outputs were committed unchanged in repository commit `72b3279d2028e8ec2af30e138e123aceb611ae8c`. The compare from `a57efcea...` to `72b3279d...` contains only those two JSON evidence files; no production, test, workflow, or validation-runner code changed. +The raw outputs were committed unchanged in repository commit `72b3279d2028e8ec2af30e138e123aceb611ae8c`. The compare from `a57efcea...` to `72b3279d...` contains only those two JSON evidence files; no numerical implementation or validation-runner code changed. ## Raw evidence @@ -76,12 +76,12 @@ The earlier canonical source measured at `faa95ce7fb5cb204088957fbda5544c20a06fb ## Applicability after evidence-only commits -The physical acceptance is anchored to the exact numerical implementation `a57efcea...`. Subsequent commits may add or promote raw evidence, canonical metadata, generated benchmark assets, and review documentation without invalidating the numerical measurement, provided a repository compare confirms that no production, test, workflow, or physical-runner implementation changed after `a57efcea...`. +The physical acceptance is anchored to the exact numerical implementation `a57efcea...`. Subsequent commits may add or promote raw evidence, canonical metadata, frontend contract tests, generated benchmark assets, and review documentation without invalidating the numerical measurement. Physical applicability is preserved provided a repository compare confirms that no numerical production implementation relevant to the measurement and neither physical validation runner changed after `a57efcea...`. -If any such implementation file changes later, a new exact-head physical validation is required before PR #122 can again be considered physically accepted. +Frontend/evidence tests may change to assert the promoted source identity or provenance; those tests do not alter the physically measured numerical implementation. If numerical production code or either physical validation runner changes later, a new exact-head physical validation is required before PR #122 can again be considered physically accepted. ## Acceptance conclusion **PHYSICAL_GPU_ACCEPTED** for Panel Tier-1 Stage B numerical implementation `a57efcea29b0e87ecb89865c5a6902d5773812c6`. -The remaining PR lifecycle work is evidence/frontend staleness synchronization, hosted final-head validation, and the normal review-thread/fresh-review process. No additional P100 rerun is required unless numerical or validation-runner code changes. +The remaining PR lifecycle work is evidence/frontend staleness synchronization, hosted final-head validation, and the normal review-thread/fresh-review process. No additional P100 rerun is required unless numerical production or physical validation-runner code changes. From ca09cb5c5875848fee03922b96195b1baf0d0afa Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 16:16:13 +0800 Subject: [PATCH 124/165] ci: temporarily sync PR122 generated assets --- .../workflows/pr122-sync-generated-assets.yml | 68 +++++++++++++++++++ 1 file changed, 68 insertions(+) create mode 100644 .github/workflows/pr122-sync-generated-assets.yml diff --git a/.github/workflows/pr122-sync-generated-assets.yml b/.github/workflows/pr122-sync-generated-assets.yml new file mode 100644 index 000000000..b18b3794b --- /dev/null +++ b/.github/workflows/pr122-sync-generated-assets.yml @@ -0,0 +1,68 @@ +name: PR122 generated benchmark asset sync + +on: + pull_request: + types: [synchronize] + +permissions: + contents: write + +jobs: + sync-generated-assets: + if: >- + github.event.pull_request.number == 122 && + github.event.pull_request.head.repo.full_name == github.repository + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + ref: ${{ github.event.pull_request.head.ref }} + fetch-depth: 0 + - uses: actions/setup-python@v5 + with: + python-version: '3.11' + - name: Install schema validation dependency + run: python -m pip install 'jsonschema[format]' + - uses: actions/setup-node@v4 + with: + node-version: '20' + - name: Generate benchmark data deterministically + run: | + python dev/benchmarks/generate_benchmark_data.py \ + --out frontend/public/data/benchmark_data.json \ + --report frontend/public/data/parse_report.json \ + --inventory-out frontend/public/data/source_inventory.json \ + --deterministic --strict-sources + - name: Build frontend mirror + run: | + cd frontend + npm ci + npm run build + - name: Verify scope and commit generated assets + shell: bash + run: | + set -euo pipefail + allowed='^( M|M |\?\?) (frontend/public/data/(benchmark_data|parse_report|source_inventory)\.json|docs/assets/benchmarks/data/(benchmark_data|parse_report|source_inventory)\.json)$' + status="$(git status --porcelain)" + printf '%s\n' "$status" + unexpected="$(printf '%s\n' "$status" | grep -Ev "$allowed" || true)" + if [ -n "$unexpected" ]; then + echo 'Unexpected generated changes:' + printf '%s\n' "$unexpected" + exit 1 + fi + git add \ + frontend/public/data/benchmark_data.json \ + frontend/public/data/parse_report.json \ + frontend/public/data/source_inventory.json \ + docs/assets/benchmarks/data/benchmark_data.json \ + docs/assets/benchmarks/data/parse_report.json \ + docs/assets/benchmarks/data/source_inventory.json + if git diff --cached --quiet; then + echo 'Generated assets already current.' + exit 0 + fi + git config user.name 'github-actions[bot]' + git config user.email '41898282+github-actions[bot]@users.noreply.github.com' + git commit -m 'benchmark: refresh PR122 frontend evidence assets' + git push origin "HEAD:${{ github.event.pull_request.head.ref }}" From 646866f99241b446f3b3c66ccd8f380b342cbccd Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Sun, 9 Aug 2026 08:16:50 +0000 Subject: [PATCH 125/165] benchmark: refresh PR122 frontend evidence assets --- .../benchmarks/data/benchmark_data.json | 1004 ++++++++--------- docs/assets/benchmarks/data/parse_report.json | 2 +- .../benchmarks/data/source_inventory.json | 54 +- frontend/public/data/benchmark_data.json | 1004 ++++++++--------- frontend/public/data/parse_report.json | 2 +- frontend/public/data/source_inventory.json | 54 +- 6 files changed, 1096 insertions(+), 1024 deletions(-) diff --git a/docs/assets/benchmarks/data/benchmark_data.json b/docs/assets/benchmarks/data/benchmark_data.json index 54d292368..d82982f24 100644 --- a/docs/assets/benchmarks/data/benchmark_data.json +++ b/docs/assets/benchmarks/data/benchmark_data.json @@ -4,7 +4,7 @@ "meta": { "generator": "dev/benchmarks/generate_benchmark_data.py", "git_sha": "deterministic", - "generation_id": "45a94e710ad14d391e40efb258f904369f3625a55d2b3080f635d98e3677609f" + "generation_id": "b086cbafb6408c586ed6e0f22e72b058489450cbbe2b401cee1dfebdf61bbf88" }, "environments": [ { @@ -29,8 +29,8 @@ "host": "wE6lDe" }, { - "env_id": "remote-p100-pr122-20260808", - "label": "Tesla P100 PR #122 Panel Stage B validation — 2026-08-08", + "env_id": "remote-p100-pr122-20260809", + "label": "Tesla P100 PR #122 Panel Stage B validation — 2026-08-09", "gpu": "Tesla P100-SXM2-16GB", "cpu": "x86_64" } @@ -605,9 +605,9 @@ "env_id": "remote-p100" }, { - "comparison_id": "panel-stage-b-pr122-20260808", - "label": "Panel Stage B physical validation — PR #122 — 2026-08-08", - "env_id": "remote-p100-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809", + "label": "Panel Stage B physical validation — PR #122 — 2026-08-09", + "env_id": "remote-p100-pr122-20260809" }, { "comparison_id": "penalized-glm-perf-20260622", @@ -91462,9 +91462,9 @@ "comparison_id": "cv-benchmark-pr116-20260807" }, { - "run_id": "8a71ce77d803ed74", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "6fbd213c0e98b871", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -91486,17 +91486,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -91524,20 +91524,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "0d85b9dd44963867", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "5e656f753d05f842", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -91559,17 +91559,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -91601,20 +91601,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "d931273510d98478", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "5e2fc37763eb7b2d", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -91636,17 +91636,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -91670,20 +91670,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "1b776255eaf957b9", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "9f8fd6d0d61957ea", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -91705,17 +91705,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -91739,20 +91739,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "c7dc0b9be6ea7fae", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "71ea69c6370cd907", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -91774,17 +91774,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -91812,20 +91812,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "b38fec0f44a85cbd", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "98d002d67524d5a9", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -91847,17 +91847,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -91885,20 +91885,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "1509019810790eb8", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "c39994c364cbb26b", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -91920,17 +91920,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -91958,20 +91958,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "6fe71f02057dde61", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "0547ff5b87d20f6b", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -91993,17 +91993,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -92027,20 +92027,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "acefbc894ee85927", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "a2007b6e73b6a9f6", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -92062,17 +92062,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -92100,20 +92100,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "dd74a3741c06baf1", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "1b69538b7e275d2b", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -92135,17 +92135,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -92173,20 +92173,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "4d70cd27967389a5", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "c9d8ef5981103295", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -92208,17 +92208,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -92250,20 +92250,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "f32ab8cd8e2aeedd", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "1423e479796ac0a4", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -92285,17 +92285,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -92319,20 +92319,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "3d1c833e7d401aef", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "d2b33efec229d231", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -92354,17 +92354,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -92388,20 +92388,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "660320ec96ec4e4e", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "777bc6b6bb7506dc", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -92423,17 +92423,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -92461,20 +92461,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "ff70c785429660ae", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "b6443da5a40e9b65", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -92496,17 +92496,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -92534,20 +92534,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "b96058e6fa248bf3", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "c018668fd1478bea", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -92569,17 +92569,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -92607,20 +92607,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "1b41ab9b767771d1", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "d1a10fdc01d5978f", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -92642,17 +92642,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -92676,20 +92676,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "9447826107945e33", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "c00879787a568092", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -92714,17 +92714,17 @@ "diagnostic": "hausman", "parameterization": "standard", "applicable": false, - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -92740,15 +92740,15 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "32e34d5c96930300", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "cdf2bce987b76e0d", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -92773,17 +92773,17 @@ "diagnostic": "hausman", "parameterization": "re-explicit-constant", "applicable": false, - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -92799,15 +92799,15 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "9e2b8c30b55698ab", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "8a49ce80e42c9187", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -92832,17 +92832,17 @@ "diagnostic": "hausman", "parameterization": "standard", "applicable": false, - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -92858,15 +92858,15 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "29bbe1904400dd6a", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "5a064e9cd732a439", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -92891,17 +92891,17 @@ "diagnostic": "hausman", "parameterization": "re-explicit-constant", "applicable": false, - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -92917,15 +92917,15 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "218fb4a5eb609091", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "b4b8ad4fdb357766", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -92947,17 +92947,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -92985,20 +92985,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "9adb6ddf275cfc14", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "cb98913de9c65567", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -93020,17 +93020,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -93062,20 +93062,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "8bab7ca73de7592f", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "229b94497b7daf39", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -93097,17 +93097,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -93131,20 +93131,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "12cf689cd1b21c9d", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "2d6ad17269f7590c", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -93166,17 +93166,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -93200,20 +93200,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "a04f5cb6744c1448", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "cd64e8c60f0d713a", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -93235,17 +93235,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -93273,20 +93273,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "da8bd2f714ec4f41", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "da676a3aae12e295", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -93308,17 +93308,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -93346,20 +93346,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "980b1ea5069ec20f", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "736e2e19a439d96e", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -93381,17 +93381,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -93419,20 +93419,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "0f98b0640c2e6b1a", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "eedb70bdf33cbefa", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -93454,17 +93454,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -93488,20 +93488,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "67063d8328552d8e", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "e0df29b034722d9c", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -93523,17 +93523,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -93561,20 +93561,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "2a6e0490de299456", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "de108bf245552035", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -93596,17 +93596,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -93634,20 +93634,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "3102e0981defbfcc", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "291d0fccf452e187", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -93669,17 +93669,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -93711,20 +93711,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "8b95ddb25cf6a2b2", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "89061c2c3eb5a5ca", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -93746,17 +93746,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -93780,20 +93780,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "a5b35d639e6ed1cd", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "d5bed9c1d4672354", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -93815,17 +93815,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -93849,20 +93849,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "ae4e242f094f74e0", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "ae0bb5e1f6073301", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -93884,17 +93884,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -93922,20 +93922,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "bdc905873c71e5e7", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "2fa9c8fffed9c95e", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -93957,17 +93957,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -93995,20 +93995,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "38b24f285a69e581", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "ce673d81fe94d27f", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -94030,17 +94030,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -94068,20 +94068,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "ad5190138d1f4299", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "7f84d1c7e0c31439", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -94103,17 +94103,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -94137,20 +94137,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "e81dfb4f8062f65e", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "b494d36de68d069f", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -94175,17 +94175,17 @@ "diagnostic": "hausman", "parameterization": "standard", "applicable": false, - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -94201,15 +94201,15 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "85f69cd996ebbdab", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "a12a554e89cac8e5", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -94234,17 +94234,17 @@ "diagnostic": "hausman", "parameterization": "re-explicit-constant", "applicable": false, - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -94260,15 +94260,15 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "76d711ed53a9060e", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "0f0059bb0eb5389a", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -94293,17 +94293,17 @@ "diagnostic": "hausman", "parameterization": "standard", "applicable": false, - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -94319,15 +94319,15 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "261d8f1d1a18f873", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "cc11ab1d8748ba1e", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -94352,17 +94352,17 @@ "diagnostic": "hausman", "parameterization": "re-explicit-constant", "applicable": false, - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -94378,10 +94378,10 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" } ] } \ No newline at end of file diff --git a/docs/assets/benchmarks/data/parse_report.json b/docs/assets/benchmarks/data/parse_report.json index e00d2611c..27c026b1f 100644 --- a/docs/assets/benchmarks/data/parse_report.json +++ b/docs/assets/benchmarks/data/parse_report.json @@ -4,7 +4,7 @@ "files_parsed": 11, "files_skipped": 0, "runs_generated": 1860, - "generation_id": "45a94e710ad14d391e40efb258f904369f3625a55d2b3080f635d98e3677609f", + "generation_id": "b086cbafb6408c586ed6e0f22e72b058489450cbbe2b401cee1dfebdf61bbf88", "issues": [ { "source_id": "glm-solver-20260623-1b6197d94d88", diff --git a/docs/assets/benchmarks/data/source_inventory.json b/docs/assets/benchmarks/data/source_inventory.json index 518d3484f..f1cfde585 100644 --- a/docs/assets/benchmarks/data/source_inventory.json +++ b/docs/assets/benchmarks/data/source_inventory.json @@ -1,18 +1,18 @@ { "inventory_version": "2.0", "catalog_version": "2.0", - "catalog_digest": "ddb41b31459bcfb1ebbd0efc20dbf1f5a747ba326b071f16fa171270ecf28717", + "catalog_digest": "da825a61685b0e54061c18e6602d368473965f232390f941673f9eb369f5a488", "coverage_matrix_version": "1.0", - "coverage_matrix_digest": "4b5f60ff535d819979d8d9e11f5c41ad6f4f3f8bb3405abdffcc03856a923113", - "discovered_json_artifacts": 91, - "classified_candidate_sources": 91, + "coverage_matrix_digest": "e7744e86819e3876b76a14d62b2dbac9506df6b809535dda1b38e36f582839dd", + "discovered_json_artifacts": 93, + "classified_candidate_sources": 93, "eligible_sources": 11, "registered_sources": 11, "available_registered_sources": 11, "parsed_registered_sources": 11, "eligible_unregistered_sources": 0, "not_canonical_ready_sources": 43, - "historical_or_excluded_sources": 37, + "historical_or_excluded_sources": 39, "superseded_or_duplicate_sources": 9, "unrelated_json_artifacts": 0, "unclassified_artifacts": 0, @@ -829,13 +829,13 @@ "rule_id": "manifest-registration" }, { - "path": "results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260808.json", + "path": "results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809.json", "artifact_type": "json", - "source_date": "2026-08-08", + "source_date": "2026-08-09", "classification": "registered_canonical", "canonical_eligible": true, "registered": true, - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", "parser": "panel_stage_b_physical_validation", "parser_version": "1.0", "provenance_status": "complete", @@ -1242,6 +1242,42 @@ "issue": "#112", "rule_id": "pr116-logistic-cv-focused-validation" }, + { + "path": "results/pr122_p100/panel_stage_b_disconnected_fe_gpu_validation_a57efcea.json", + "artifact_type": "json", + "source_date": null, + "classification": "historical_or_excluded", + "canonical_eligible": false, + "registered": false, + "source_id": null, + "parser": null, + "parser_version": null, + "provenance_status": "incomplete_date", + "timing_protocol_status": "unknown", + "statistical_alignment_status": "unknown", + "reason": "Artifact has no deterministically recoverable result date and is excluded pending explicit provenance review.", + "superseded_by": null, + "issue": "#100", + "rule_id": "undated-json" + }, + { + "path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "artifact_type": "json", + "source_date": null, + "classification": "historical_or_excluded", + "canonical_eligible": false, + "registered": false, + "source_id": null, + "parser": null, + "parser_version": null, + "provenance_status": "incomplete_date", + "timing_protocol_status": "unknown", + "statistical_alignment_status": "unknown", + "reason": "Artifact has no deterministically recoverable result date and is excluded pending explicit provenance review.", + "superseded_by": null, + "issue": "#100", + "rule_id": "undated-json" + }, { "path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", "artifact_type": "json", @@ -1663,5 +1699,5 @@ "current_evidence_not_canonical_ready": 2, "partial_canonical": 7 }, - "generation_id": "45a94e710ad14d391e40efb258f904369f3625a55d2b3080f635d98e3677609f" + "generation_id": "b086cbafb6408c586ed6e0f22e72b058489450cbbe2b401cee1dfebdf61bbf88" } \ No newline at end of file diff --git a/frontend/public/data/benchmark_data.json b/frontend/public/data/benchmark_data.json index 54d292368..d82982f24 100644 --- a/frontend/public/data/benchmark_data.json +++ b/frontend/public/data/benchmark_data.json @@ -4,7 +4,7 @@ "meta": { "generator": "dev/benchmarks/generate_benchmark_data.py", "git_sha": "deterministic", - "generation_id": "45a94e710ad14d391e40efb258f904369f3625a55d2b3080f635d98e3677609f" + "generation_id": "b086cbafb6408c586ed6e0f22e72b058489450cbbe2b401cee1dfebdf61bbf88" }, "environments": [ { @@ -29,8 +29,8 @@ "host": "wE6lDe" }, { - "env_id": "remote-p100-pr122-20260808", - "label": "Tesla P100 PR #122 Panel Stage B validation — 2026-08-08", + "env_id": "remote-p100-pr122-20260809", + "label": "Tesla P100 PR #122 Panel Stage B validation — 2026-08-09", "gpu": "Tesla P100-SXM2-16GB", "cpu": "x86_64" } @@ -605,9 +605,9 @@ "env_id": "remote-p100" }, { - "comparison_id": "panel-stage-b-pr122-20260808", - "label": "Panel Stage B physical validation — PR #122 — 2026-08-08", - "env_id": "remote-p100-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809", + "label": "Panel Stage B physical validation — PR #122 — 2026-08-09", + "env_id": "remote-p100-pr122-20260809" }, { "comparison_id": "penalized-glm-perf-20260622", @@ -91462,9 +91462,9 @@ "comparison_id": "cv-benchmark-pr116-20260807" }, { - "run_id": "8a71ce77d803ed74", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "6fbd213c0e98b871", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -91486,17 +91486,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -91524,20 +91524,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "0d85b9dd44963867", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "5e656f753d05f842", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -91559,17 +91559,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -91601,20 +91601,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "d931273510d98478", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "5e2fc37763eb7b2d", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -91636,17 +91636,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -91670,20 +91670,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "1b776255eaf957b9", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "9f8fd6d0d61957ea", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -91705,17 +91705,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -91739,20 +91739,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "c7dc0b9be6ea7fae", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "71ea69c6370cd907", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -91774,17 +91774,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -91812,20 +91812,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "b38fec0f44a85cbd", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "98d002d67524d5a9", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -91847,17 +91847,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -91885,20 +91885,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "1509019810790eb8", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "c39994c364cbb26b", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -91920,17 +91920,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -91958,20 +91958,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "6fe71f02057dde61", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "0547ff5b87d20f6b", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -91993,17 +91993,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -92027,20 +92027,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "acefbc894ee85927", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "a2007b6e73b6a9f6", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -92062,17 +92062,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -92100,20 +92100,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "dd74a3741c06baf1", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "1b69538b7e275d2b", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -92135,17 +92135,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -92173,20 +92173,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "4d70cd27967389a5", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "c9d8ef5981103295", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -92208,17 +92208,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -92250,20 +92250,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "f32ab8cd8e2aeedd", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "1423e479796ac0a4", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -92285,17 +92285,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -92319,20 +92319,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "3d1c833e7d401aef", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "d2b33efec229d231", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -92354,17 +92354,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -92388,20 +92388,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "660320ec96ec4e4e", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "777bc6b6bb7506dc", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -92423,17 +92423,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -92461,20 +92461,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "ff70c785429660ae", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "b6443da5a40e9b65", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -92496,17 +92496,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -92534,20 +92534,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "b96058e6fa248bf3", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "c018668fd1478bea", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -92569,17 +92569,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -92607,20 +92607,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "1b41ab9b767771d1", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "d1a10fdc01d5978f", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -92642,17 +92642,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -92676,20 +92676,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "9447826107945e33", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "c00879787a568092", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -92714,17 +92714,17 @@ "diagnostic": "hausman", "parameterization": "standard", "applicable": false, - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -92740,15 +92740,15 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "32e34d5c96930300", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "cdf2bce987b76e0d", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -92773,17 +92773,17 @@ "diagnostic": "hausman", "parameterization": "re-explicit-constant", "applicable": false, - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -92799,15 +92799,15 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "9e2b8c30b55698ab", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "8a49ce80e42c9187", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -92832,17 +92832,17 @@ "diagnostic": "hausman", "parameterization": "standard", "applicable": false, - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -92858,15 +92858,15 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "29bbe1904400dd6a", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "5a064e9cd732a439", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -92891,17 +92891,17 @@ "diagnostic": "hausman", "parameterization": "re-explicit-constant", "applicable": false, - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -92917,15 +92917,15 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "218fb4a5eb609091", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "b4b8ad4fdb357766", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -92947,17 +92947,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -92985,20 +92985,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "9adb6ddf275cfc14", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "cb98913de9c65567", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -93020,17 +93020,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -93062,20 +93062,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "8bab7ca73de7592f", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "229b94497b7daf39", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -93097,17 +93097,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -93131,20 +93131,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "12cf689cd1b21c9d", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "2d6ad17269f7590c", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -93166,17 +93166,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -93200,20 +93200,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "a04f5cb6744c1448", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "cd64e8c60f0d713a", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -93235,17 +93235,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -93273,20 +93273,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "da8bd2f714ec4f41", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "da676a3aae12e295", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -93308,17 +93308,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -93346,20 +93346,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "980b1ea5069ec20f", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "736e2e19a439d96e", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -93381,17 +93381,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -93419,20 +93419,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "0f98b0640c2e6b1a", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "eedb70bdf33cbefa", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -93454,17 +93454,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -93488,20 +93488,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "67063d8328552d8e", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "e0df29b034722d9c", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -93523,17 +93523,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -93561,20 +93561,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "2a6e0490de299456", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "de108bf245552035", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -93596,17 +93596,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -93634,20 +93634,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "3102e0981defbfcc", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "291d0fccf452e187", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -93669,17 +93669,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -93711,20 +93711,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "8b95ddb25cf6a2b2", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "89061c2c3eb5a5ca", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -93746,17 +93746,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -93780,20 +93780,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "a5b35d639e6ed1cd", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "d5bed9c1d4672354", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -93815,17 +93815,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -93849,20 +93849,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "ae4e242f094f74e0", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "ae0bb5e1f6073301", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -93884,17 +93884,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -93922,20 +93922,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "bdc905873c71e5e7", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "2fa9c8fffed9c95e", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -93957,17 +93957,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -93995,20 +93995,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "38b24f285a69e581", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "ce673d81fe94d27f", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -94030,17 +94030,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -94068,20 +94068,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "ad5190138d1f4299", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "7f84d1c7e0c31439", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -94103,17 +94103,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -94137,20 +94137,20 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "e81dfb4f8062f65e", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "b494d36de68d069f", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -94175,17 +94175,17 @@ "diagnostic": "hausman", "parameterization": "standard", "applicable": false, - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -94201,15 +94201,15 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "85f69cd996ebbdab", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "a12a554e89cac8e5", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -94234,17 +94234,17 @@ "diagnostic": "hausman", "parameterization": "re-explicit-constant", "applicable": false, - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -94260,15 +94260,15 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "76d711ed53a9060e", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "0f0059bb0eb5389a", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -94293,17 +94293,17 @@ "diagnostic": "hausman", "parameterization": "standard", "applicable": false, - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -94319,15 +94319,15 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "261d8f1d1a18f873", - "benchmark_session_id": "remote-p100-pr122-20260808-panel-stage-b-pr122", - "env_id": "remote-p100-pr122-20260808", + "run_id": "cc11ab1d8748ba1e", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", "category_ids": [ "panel" ], @@ -94352,17 +94352,17 @@ "diagnostic": "hausman", "parameterization": "re-explicit-constant", "applicable": false, - "measurement_git_sha": "faa95ce7fb5cb204088957fbda5544c20a06fbfc", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260808.json", - "date": "2026-08-08", + "file": "panel_stage_b_pr122_p100_20260809.json", + "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", - "sha256": "b8caffa6f915facfb74965b6834b06d8aa6480cb0e3822640261a77ddd1ec9ba" + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" }, "metrics": { "validation": { @@ -94378,10 +94378,10 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260808.json" + "source_file": "panel_stage_b_pr122_p100_20260809.json" } }, - "comparison_id": "panel-stage-b-pr122-20260808" + "comparison_id": "panel-stage-b-pr122-20260809" } ] } \ No newline at end of file diff --git a/frontend/public/data/parse_report.json b/frontend/public/data/parse_report.json index e00d2611c..27c026b1f 100644 --- a/frontend/public/data/parse_report.json +++ b/frontend/public/data/parse_report.json @@ -4,7 +4,7 @@ "files_parsed": 11, "files_skipped": 0, "runs_generated": 1860, - "generation_id": "45a94e710ad14d391e40efb258f904369f3625a55d2b3080f635d98e3677609f", + "generation_id": "b086cbafb6408c586ed6e0f22e72b058489450cbbe2b401cee1dfebdf61bbf88", "issues": [ { "source_id": "glm-solver-20260623-1b6197d94d88", diff --git a/frontend/public/data/source_inventory.json b/frontend/public/data/source_inventory.json index 518d3484f..f1cfde585 100644 --- a/frontend/public/data/source_inventory.json +++ b/frontend/public/data/source_inventory.json @@ -1,18 +1,18 @@ { "inventory_version": "2.0", "catalog_version": "2.0", - "catalog_digest": "ddb41b31459bcfb1ebbd0efc20dbf1f5a747ba326b071f16fa171270ecf28717", + "catalog_digest": "da825a61685b0e54061c18e6602d368473965f232390f941673f9eb369f5a488", "coverage_matrix_version": "1.0", - "coverage_matrix_digest": "4b5f60ff535d819979d8d9e11f5c41ad6f4f3f8bb3405abdffcc03856a923113", - "discovered_json_artifacts": 91, - "classified_candidate_sources": 91, + "coverage_matrix_digest": "e7744e86819e3876b76a14d62b2dbac9506df6b809535dda1b38e36f582839dd", + "discovered_json_artifacts": 93, + "classified_candidate_sources": 93, "eligible_sources": 11, "registered_sources": 11, "available_registered_sources": 11, "parsed_registered_sources": 11, "eligible_unregistered_sources": 0, "not_canonical_ready_sources": 43, - "historical_or_excluded_sources": 37, + "historical_or_excluded_sources": 39, "superseded_or_duplicate_sources": 9, "unrelated_json_artifacts": 0, "unclassified_artifacts": 0, @@ -829,13 +829,13 @@ "rule_id": "manifest-registration" }, { - "path": "results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260808.json", + "path": "results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809.json", "artifact_type": "json", - "source_date": "2026-08-08", + "source_date": "2026-08-09", "classification": "registered_canonical", "canonical_eligible": true, "registered": true, - "source_id": "panel-stage-b-pr122-20260808-b8caffa6f915", + "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", "parser": "panel_stage_b_physical_validation", "parser_version": "1.0", "provenance_status": "complete", @@ -1242,6 +1242,42 @@ "issue": "#112", "rule_id": "pr116-logistic-cv-focused-validation" }, + { + "path": "results/pr122_p100/panel_stage_b_disconnected_fe_gpu_validation_a57efcea.json", + "artifact_type": "json", + "source_date": null, + "classification": "historical_or_excluded", + "canonical_eligible": false, + "registered": false, + "source_id": null, + "parser": null, + "parser_version": null, + "provenance_status": "incomplete_date", + "timing_protocol_status": "unknown", + "statistical_alignment_status": "unknown", + "reason": "Artifact has no deterministically recoverable result date and is excluded pending explicit provenance review.", + "superseded_by": null, + "issue": "#100", + "rule_id": "undated-json" + }, + { + "path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", + "artifact_type": "json", + "source_date": null, + "classification": "historical_or_excluded", + "canonical_eligible": false, + "registered": false, + "source_id": null, + "parser": null, + "parser_version": null, + "provenance_status": "incomplete_date", + "timing_protocol_status": "unknown", + "statistical_alignment_status": "unknown", + "reason": "Artifact has no deterministically recoverable result date and is excluded pending explicit provenance review.", + "superseded_by": null, + "issue": "#100", + "rule_id": "undated-json" + }, { "path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", "artifact_type": "json", @@ -1663,5 +1699,5 @@ "current_evidence_not_canonical_ready": 2, "partial_canonical": 7 }, - "generation_id": "45a94e710ad14d391e40efb258f904369f3625a55d2b3080f635d98e3677609f" + "generation_id": "b086cbafb6408c586ed6e0f22e72b058489450cbbe2b401cee1dfebdf61bbf88" } \ No newline at end of file From fd1ab5a9d350b4acfb2dec2d59416d4a6c510c3b Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 16:17:07 +0800 Subject: [PATCH 126/165] ci: temporarily sync PR122 benchmark assets --- .github/workflows/benchmark-frontend.yml | 37 ++++++++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/.github/workflows/benchmark-frontend.yml b/.github/workflows/benchmark-frontend.yml index 683318920..b997d6c16 100644 --- a/.github/workflows/benchmark-frontend.yml +++ b/.github/workflows/benchmark-frontend.yml @@ -39,6 +39,9 @@ on: - 'results/benchmark_frontend_sources/**' - 'pyproject.toml' +permissions: + contents: write + concurrency: group: benchmark-frontend-${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }} cancel-in-progress: true @@ -98,6 +101,9 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 + with: + ref: ${{ github.event.pull_request.head.ref || github.ref }} + fetch-depth: 0 - uses: actions/setup-python@v5 with: python-version: '3.11' @@ -118,6 +124,37 @@ jobs: cd frontend npm ci npm run build + - name: Commit PR122 generated benchmark assets + if: >- + github.event_name == 'pull_request' && + github.event.pull_request.number == 122 && + github.event.pull_request.head.repo.full_name == github.repository + shell: bash + run: | + set -euo pipefail + status="$(git status --porcelain -- frontend/public/data docs/assets/benchmarks)" + printf '%s\n' "$status" + unexpected="$(printf '%s\n' "$status" | grep -Ev '^( M|M |\?\?) (frontend/public/data/(benchmark_data|parse_report|source_inventory)\.json|docs/assets/benchmarks/data/(benchmark_data|parse_report|source_inventory)\.json)$' || true)" + if [ -n "$unexpected" ]; then + echo "Unexpected generated changes:" + printf '%s\n' "$unexpected" + exit 1 + fi + git add \ + frontend/public/data/benchmark_data.json \ + frontend/public/data/parse_report.json \ + frontend/public/data/source_inventory.json \ + docs/assets/benchmarks/data/benchmark_data.json \ + docs/assets/benchmarks/data/parse_report.json \ + docs/assets/benchmarks/data/source_inventory.json + if git diff --cached --quiet; then + echo "Generated assets already current." + exit 0 + fi + git config user.name 'github-actions[bot]' + git config user.email '41898282+github-actions[bot]@users.noreply.github.com' + git commit -m 'benchmark: refresh PR122 frontend evidence assets' + git push origin "HEAD:${{ github.event.pull_request.head.ref }}" - name: Check staleness run: | changes="$(git status --porcelain -- frontend/public/data docs/assets/benchmarks)" From ba5b2b2c22c09679e93e8a6248def5979ff60e25 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 16:18:53 +0800 Subject: [PATCH 127/165] ci: remove temporary PR122 asset sync --- .github/workflows/benchmark-frontend.yml | 37 ---------- .../workflows/pr122-sync-generated-assets.yml | 68 ------------------- 2 files changed, 105 deletions(-) delete mode 100644 .github/workflows/pr122-sync-generated-assets.yml diff --git a/.github/workflows/benchmark-frontend.yml b/.github/workflows/benchmark-frontend.yml index b997d6c16..683318920 100644 --- a/.github/workflows/benchmark-frontend.yml +++ b/.github/workflows/benchmark-frontend.yml @@ -39,9 +39,6 @@ on: - 'results/benchmark_frontend_sources/**' - 'pyproject.toml' -permissions: - contents: write - concurrency: group: benchmark-frontend-${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }} cancel-in-progress: true @@ -101,9 +98,6 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - with: - ref: ${{ github.event.pull_request.head.ref || github.ref }} - fetch-depth: 0 - uses: actions/setup-python@v5 with: python-version: '3.11' @@ -124,37 +118,6 @@ jobs: cd frontend npm ci npm run build - - name: Commit PR122 generated benchmark assets - if: >- - github.event_name == 'pull_request' && - github.event.pull_request.number == 122 && - github.event.pull_request.head.repo.full_name == github.repository - shell: bash - run: | - set -euo pipefail - status="$(git status --porcelain -- frontend/public/data docs/assets/benchmarks)" - printf '%s\n' "$status" - unexpected="$(printf '%s\n' "$status" | grep -Ev '^( M|M |\?\?) (frontend/public/data/(benchmark_data|parse_report|source_inventory)\.json|docs/assets/benchmarks/data/(benchmark_data|parse_report|source_inventory)\.json)$' || true)" - if [ -n "$unexpected" ]; then - echo "Unexpected generated changes:" - printf '%s\n' "$unexpected" - exit 1 - fi - git add \ - frontend/public/data/benchmark_data.json \ - frontend/public/data/parse_report.json \ - frontend/public/data/source_inventory.json \ - docs/assets/benchmarks/data/benchmark_data.json \ - docs/assets/benchmarks/data/parse_report.json \ - docs/assets/benchmarks/data/source_inventory.json - if git diff --cached --quiet; then - echo "Generated assets already current." - exit 0 - fi - git config user.name 'github-actions[bot]' - git config user.email '41898282+github-actions[bot]@users.noreply.github.com' - git commit -m 'benchmark: refresh PR122 frontend evidence assets' - git push origin "HEAD:${{ github.event.pull_request.head.ref }}" - name: Check staleness run: | changes="$(git status --porcelain -- frontend/public/data docs/assets/benchmarks)" diff --git a/.github/workflows/pr122-sync-generated-assets.yml b/.github/workflows/pr122-sync-generated-assets.yml deleted file mode 100644 index b18b3794b..000000000 --- a/.github/workflows/pr122-sync-generated-assets.yml +++ /dev/null @@ -1,68 +0,0 @@ -name: PR122 generated benchmark asset sync - -on: - pull_request: - types: [synchronize] - -permissions: - contents: write - -jobs: - sync-generated-assets: - if: >- - github.event.pull_request.number == 122 && - github.event.pull_request.head.repo.full_name == github.repository - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v4 - with: - ref: ${{ github.event.pull_request.head.ref }} - fetch-depth: 0 - - uses: actions/setup-python@v5 - with: - python-version: '3.11' - - name: Install schema validation dependency - run: python -m pip install 'jsonschema[format]' - - uses: actions/setup-node@v4 - with: - node-version: '20' - - name: Generate benchmark data deterministically - run: | - python dev/benchmarks/generate_benchmark_data.py \ - --out frontend/public/data/benchmark_data.json \ - --report frontend/public/data/parse_report.json \ - --inventory-out frontend/public/data/source_inventory.json \ - --deterministic --strict-sources - - name: Build frontend mirror - run: | - cd frontend - npm ci - npm run build - - name: Verify scope and commit generated assets - shell: bash - run: | - set -euo pipefail - allowed='^( M|M |\?\?) (frontend/public/data/(benchmark_data|parse_report|source_inventory)\.json|docs/assets/benchmarks/data/(benchmark_data|parse_report|source_inventory)\.json)$' - status="$(git status --porcelain)" - printf '%s\n' "$status" - unexpected="$(printf '%s\n' "$status" | grep -Ev "$allowed" || true)" - if [ -n "$unexpected" ]; then - echo 'Unexpected generated changes:' - printf '%s\n' "$unexpected" - exit 1 - fi - git add \ - frontend/public/data/benchmark_data.json \ - frontend/public/data/parse_report.json \ - frontend/public/data/source_inventory.json \ - docs/assets/benchmarks/data/benchmark_data.json \ - docs/assets/benchmarks/data/parse_report.json \ - docs/assets/benchmarks/data/source_inventory.json - if git diff --cached --quiet; then - echo 'Generated assets already current.' - exit 0 - fi - git config user.name 'github-actions[bot]' - git config user.email '41898282+github-actions[bot]@users.noreply.github.com' - git commit -m 'benchmark: refresh PR122 frontend evidence assets' - git push origin "HEAD:${{ github.event.pull_request.head.ref }}" From fb29114644fead59e4e8870f8e01e653c4a8e7b5 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 18:25:23 +0800 Subject: [PATCH 128/165] ci: temporarily stage PR122 Hausman physical gate fix --- .../pr122-autofix-applicable-hausman.yml | 275 ++++++++++++++++++ 1 file changed, 275 insertions(+) create mode 100644 .github/workflows/pr122-autofix-applicable-hausman.yml diff --git a/.github/workflows/pr122-autofix-applicable-hausman.yml b/.github/workflows/pr122-autofix-applicable-hausman.yml new file mode 100644 index 000000000..14898c930 --- /dev/null +++ b/.github/workflows/pr122-autofix-applicable-hausman.yml @@ -0,0 +1,275 @@ +name: PR122 Applicable Hausman Autofix + +on: + push: + branches: + - agent/panel-p1-stage-b-diagnostics + paths: + - .github/workflows/pr122-autofix-applicable-hausman.yml + +permissions: + contents: write + +jobs: + autofix: + if: github.actor != 'github-actions[bot]' + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + ref: agent/panel-p1-stage-b-diagnostics + fetch-depth: 0 + + - uses: actions/setup-python@v5 + with: + python-version: '3.11' + + - name: Patch physical Hausman coverage gate + shell: bash + run: | + python - <<'PY' + from pathlib import Path + + runner_path = Path('dev/benchmarks/validate_panel_stage_b_gpu.py') + runner = runner_path.read_text(encoding='utf-8') + + anchor = " return cases, diagnostics\n\n\ndef _scalar_diff(actual, expected, *, rtol, atol, label):\n" + replacement = ''' return cases, diagnostics + + +def _hausman_applicable_dataset(seed: int): + """Return a deterministic one-way panel suited to an applicable Hausman gate.""" + rng = np.random.default_rng(seed) + n_entities, n_times = 32, 8 + entity = np.repeat(np.arange(n_entities), n_times) + time = np.tile(np.arange(n_times), n_entities) + X = rng.normal(size=(entity.size, 2)) + random_effect = np.repeat(rng.normal(scale=0.65, size=n_entities), n_times) + y = ( + 0.8 * X[:, 0] + - 0.35 * X[:, 1] + + random_effect + + rng.normal(scale=0.2, size=entity.size) + ) + return X.astype(np.float64), y.astype(np.float64), entity, time + + +def _find_applicable_hausman_fixture(*, start_seed=20260810, max_attempts=512): + """Find a bounded deterministic NumPy fixture with an applicable Hausman test.""" + for seed in range(int(start_seed), int(start_seed) + int(max_attempts)): + X, y, entity, time = _hausman_applicable_dataset(seed) + fe = PanelOLS(entity_effects=True, cov_type="nonrobust", device="cpu").fit( + X, y, entity_ids=entity + ) + re = RandomEffects(device="cpu").fit(X, y, entity_ids=entity) + result = _test_result(fe.hausman_test(re)) + if ( + result["applicable"] + and result["statistic"] is not None + and result["pvalue"] is not None + and result["df"] is not None + and np.isfinite(float(result["statistic"])) + and np.isfinite(float(result["pvalue"])) + and float(result["df"]) > 0.0 + ): + return { + "seed": int(seed), + "X": X, + "y": y, + "entity": entity, + "time": time, + "reference": result, + } + raise RuntimeError( + "unable to find an applicable Hausman fixture within the bounded seed search" + ) + + +def _require_applicable_hausman_coverage(diagnostics, *, backend): + """Require at least one physically executed applicable Hausman diagnostic.""" + applicable = sorted( + name + for name, payload in diagnostics.items() + if payload.get("applicable") is True + ) + if not applicable: + raise AssertionError( + f"{backend}: physical Hausman gate requires at least one applicable case" + ) + return applicable + + +def _scalar_diff(actual, expected, *, rtol, atol, label): +''' + if anchor not in runner: + raise SystemExit('runner helper anchor not found') + runner = runner.replace(anchor, replacement, 1) + + anchor = " reference_diagnostics.update(diagnostics)\n\n results = {}\n" + replacement = ''' reference_diagnostics.update(diagnostics) + + applicable_fixture = _find_applicable_hausman_fixture() + reference_diagnostics["hausman_applicable_physical"] = applicable_fixture[ + "reference" + ] + + results = {} +''' + if anchor not in runner: + raise SystemExit('reference fixture anchor not found') + runner = runner.replace(anchor, replacement, 1) + + anchor = " results[backend] = backend_payload\n\n payload = {\n" + replacement = ''' Xf = applicable_fixture["X"] + yf = applicable_fixture["y"] + ef = applicable_fixture["entity"] + tf = applicable_fixture["time"] + Xfb, yfb, efb, _ = _to_backend_arrays(Xf, yf, ef, tf, backend) + device = _device_arg(backend) + fe_applicable = PanelOLS( + entity_effects=True, + cov_type="nonrobust", + device=device, + ).fit(Xfb, yfb, entity_ids=efb) + re_applicable = RandomEffects(device=device).fit(Xfb, yfb, entity_ids=efb) + for model_name, model in ( + ("hausman_applicable_fe", fe_applicable), + ("hausman_applicable_re", re_applicable), + ): + actual_backend = _backend_name(model) + if actual_backend != backend: + raise AssertionError( + f"{model_name}: requested {backend}, executed {actual_backend}" + ) + + applicable_result = _test_result( + fe_applicable.hausman_test(re_applicable) + ) + if not applicable_result["applicable"]: + raise AssertionError( + f"hausman_applicable_physical unexpectedly inapplicable on {backend}: " + f"{applicable_result['reason']}" + ) + differences = _compare_test_result( + reference_diagnostics["hausman_applicable_physical"], + applicable_result, + rtol=args.rtol, + atol=args.atol, + label="hausman_applicable_physical", + ) + backend_payload["diagnostics"]["hausman_applicable_physical"] = { + "status": "success", + "max_abs_differences": differences, + "applicable": True, + "reason": applicable_result["reason"], + "fixture_seed": applicable_fixture["seed"], + "nobs": int(len(yf)), + } + _require_applicable_hausman_coverage( + backend_payload["diagnostics"], backend=backend + ) + results[backend] = backend_payload + + payload = { +''' + if anchor not in runner: + raise SystemExit('backend coverage anchor not found') + runner = runner.replace(anchor, replacement, 1) + + anchor = ''' "datasets": { + name: {"nobs": int(len(values[1]))} + for name, values in datasets.items() + }, +''' + replacement = ''' "datasets": { + **{ + name: {"nobs": int(len(values[1]))} + for name, values in datasets.items() + }, + "hausman_applicable": { + "nobs": int(len(applicable_fixture["y"])), + "seed": applicable_fixture["seed"], + }, + }, +''' + if anchor not in runner: + raise SystemExit('dataset metadata anchor not found') + runner = runner.replace(anchor, replacement, 1) + runner_path.write_text(runner, encoding='utf-8') + + test_path = Path('dev/tests/test_panel_stage_b_physical_runner_contract.py') + test = test_path.read_text(encoding='utf-8') + test = test.replace( + 'from __future__ import annotations\n\nfrom dev.benchmarks.validate_panel_stage_b_gpu import (\n', + 'from __future__ import annotations\n\nimport numpy as np\nimport pytest\n\nfrom dev.benchmarks.validate_panel_stage_b_gpu import (\n', + 1, + ) + test = test.replace( + ' _dataset,\n _fit_cases,\n _model_snapshot,\n', + ' _dataset,\n _find_applicable_hausman_fixture,\n _fit_cases,\n _model_snapshot,\n _require_applicable_hausman_coverage,\n', + 1, + ) + test += ''' + + +def test_physical_runner_finds_applicable_hausman_reference_fixture(): + fixture = _find_applicable_hausman_fixture() + result = fixture["reference"] + + assert result["applicable"] is True + assert result["reason"] is None + assert result["df"] is not None and float(result["df"]) > 0.0 + assert np.isfinite(float(result["statistic"])) + assert np.isfinite(float(result["pvalue"])) + assert fixture["X"].shape[0] == fixture["y"].shape[0] + assert fixture["entity"].shape[0] == fixture["y"].shape[0] + + +def test_physical_runner_requires_applicable_hausman_per_backend(): + with pytest.raises(AssertionError, match="requires at least one applicable"): + _require_applicable_hausman_coverage( + { + "hausman_balanced": {"applicable": False}, + "hausman_unbalanced": {"applicable": False}, + }, + backend="torch", + ) + + applicable = _require_applicable_hausman_coverage( + { + "hausman_balanced": {"applicable": False}, + "hausman_applicable_physical": {"applicable": True}, + }, + backend="cupy", + ) + assert applicable == ["hausman_applicable_physical"] +''' + test_path.write_text(test, encoding='utf-8') + PY + + - name: Install targeted test dependencies + run: | + python -m pip install --upgrade pip + python -m pip install -e . pytest + + - name: Run targeted Stage-B review gates + run: | + python -m pytest -q \ + dev/tests/test_panel_stage_b_physical_runner_contract.py \ + dev/tests/test_panel_stage_b_diagnostics.py \ + dev/tests/test_panel_stage_b_hausman_covariance.py \ + dev/tests/test_panel_stage_b_review_regressions.py + git diff --check + + - name: Commit focused fix and remove temporary workflow + shell: bash + run: | + rm .github/workflows/pr122-autofix-applicable-hausman.yml + git diff --check + git config user.name 'github-actions[bot]' + git config user.email '41898282+github-actions[bot]@users.noreply.github.com' + git add dev/benchmarks/validate_panel_stage_b_gpu.py \ + dev/tests/test_panel_stage_b_physical_runner_contract.py \ + .github/workflows/pr122-autofix-applicable-hausman.yml + git commit -m 'test: require applicable Hausman GPU coverage' + git push origin HEAD:agent/panel-p1-stage-b-diagnostics From 883cba188510eedb061ae1e7f7652a7b52f54968 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 18:27:58 +0800 Subject: [PATCH 129/165] ci: repair PR122 Hausman autofix carrier --- .../pr122-autofix-applicable-hausman.yml | 224 +----------------- 1 file changed, 1 insertion(+), 223 deletions(-) diff --git a/.github/workflows/pr122-autofix-applicable-hausman.yml b/.github/workflows/pr122-autofix-applicable-hausman.yml index 14898c930..999b90d20 100644 --- a/.github/workflows/pr122-autofix-applicable-hausman.yml +++ b/.github/workflows/pr122-autofix-applicable-hausman.yml @@ -12,7 +12,6 @@ permissions: jobs: autofix: - if: github.actor != 'github-actions[bot]' runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 @@ -25,227 +24,7 @@ jobs: python-version: '3.11' - name: Patch physical Hausman coverage gate - shell: bash - run: | - python - <<'PY' - from pathlib import Path - - runner_path = Path('dev/benchmarks/validate_panel_stage_b_gpu.py') - runner = runner_path.read_text(encoding='utf-8') - - anchor = " return cases, diagnostics\n\n\ndef _scalar_diff(actual, expected, *, rtol, atol, label):\n" - replacement = ''' return cases, diagnostics - - -def _hausman_applicable_dataset(seed: int): - """Return a deterministic one-way panel suited to an applicable Hausman gate.""" - rng = np.random.default_rng(seed) - n_entities, n_times = 32, 8 - entity = np.repeat(np.arange(n_entities), n_times) - time = np.tile(np.arange(n_times), n_entities) - X = rng.normal(size=(entity.size, 2)) - random_effect = np.repeat(rng.normal(scale=0.65, size=n_entities), n_times) - y = ( - 0.8 * X[:, 0] - - 0.35 * X[:, 1] - + random_effect - + rng.normal(scale=0.2, size=entity.size) - ) - return X.astype(np.float64), y.astype(np.float64), entity, time - - -def _find_applicable_hausman_fixture(*, start_seed=20260810, max_attempts=512): - """Find a bounded deterministic NumPy fixture with an applicable Hausman test.""" - for seed in range(int(start_seed), int(start_seed) + int(max_attempts)): - X, y, entity, time = _hausman_applicable_dataset(seed) - fe = PanelOLS(entity_effects=True, cov_type="nonrobust", device="cpu").fit( - X, y, entity_ids=entity - ) - re = RandomEffects(device="cpu").fit(X, y, entity_ids=entity) - result = _test_result(fe.hausman_test(re)) - if ( - result["applicable"] - and result["statistic"] is not None - and result["pvalue"] is not None - and result["df"] is not None - and np.isfinite(float(result["statistic"])) - and np.isfinite(float(result["pvalue"])) - and float(result["df"]) > 0.0 - ): - return { - "seed": int(seed), - "X": X, - "y": y, - "entity": entity, - "time": time, - "reference": result, - } - raise RuntimeError( - "unable to find an applicable Hausman fixture within the bounded seed search" - ) - - -def _require_applicable_hausman_coverage(diagnostics, *, backend): - """Require at least one physically executed applicable Hausman diagnostic.""" - applicable = sorted( - name - for name, payload in diagnostics.items() - if payload.get("applicable") is True - ) - if not applicable: - raise AssertionError( - f"{backend}: physical Hausman gate requires at least one applicable case" - ) - return applicable - - -def _scalar_diff(actual, expected, *, rtol, atol, label): -''' - if anchor not in runner: - raise SystemExit('runner helper anchor not found') - runner = runner.replace(anchor, replacement, 1) - - anchor = " reference_diagnostics.update(diagnostics)\n\n results = {}\n" - replacement = ''' reference_diagnostics.update(diagnostics) - - applicable_fixture = _find_applicable_hausman_fixture() - reference_diagnostics["hausman_applicable_physical"] = applicable_fixture[ - "reference" - ] - - results = {} -''' - if anchor not in runner: - raise SystemExit('reference fixture anchor not found') - runner = runner.replace(anchor, replacement, 1) - - anchor = " results[backend] = backend_payload\n\n payload = {\n" - replacement = ''' Xf = applicable_fixture["X"] - yf = applicable_fixture["y"] - ef = applicable_fixture["entity"] - tf = applicable_fixture["time"] - Xfb, yfb, efb, _ = _to_backend_arrays(Xf, yf, ef, tf, backend) - device = _device_arg(backend) - fe_applicable = PanelOLS( - entity_effects=True, - cov_type="nonrobust", - device=device, - ).fit(Xfb, yfb, entity_ids=efb) - re_applicable = RandomEffects(device=device).fit(Xfb, yfb, entity_ids=efb) - for model_name, model in ( - ("hausman_applicable_fe", fe_applicable), - ("hausman_applicable_re", re_applicable), - ): - actual_backend = _backend_name(model) - if actual_backend != backend: - raise AssertionError( - f"{model_name}: requested {backend}, executed {actual_backend}" - ) - - applicable_result = _test_result( - fe_applicable.hausman_test(re_applicable) - ) - if not applicable_result["applicable"]: - raise AssertionError( - f"hausman_applicable_physical unexpectedly inapplicable on {backend}: " - f"{applicable_result['reason']}" - ) - differences = _compare_test_result( - reference_diagnostics["hausman_applicable_physical"], - applicable_result, - rtol=args.rtol, - atol=args.atol, - label="hausman_applicable_physical", - ) - backend_payload["diagnostics"]["hausman_applicable_physical"] = { - "status": "success", - "max_abs_differences": differences, - "applicable": True, - "reason": applicable_result["reason"], - "fixture_seed": applicable_fixture["seed"], - "nobs": int(len(yf)), - } - _require_applicable_hausman_coverage( - backend_payload["diagnostics"], backend=backend - ) - results[backend] = backend_payload - - payload = { -''' - if anchor not in runner: - raise SystemExit('backend coverage anchor not found') - runner = runner.replace(anchor, replacement, 1) - - anchor = ''' "datasets": { - name: {"nobs": int(len(values[1]))} - for name, values in datasets.items() - }, -''' - replacement = ''' "datasets": { - **{ - name: {"nobs": int(len(values[1]))} - for name, values in datasets.items() - }, - "hausman_applicable": { - "nobs": int(len(applicable_fixture["y"])), - "seed": applicable_fixture["seed"], - }, - }, -''' - if anchor not in runner: - raise SystemExit('dataset metadata anchor not found') - runner = runner.replace(anchor, replacement, 1) - runner_path.write_text(runner, encoding='utf-8') - - test_path = Path('dev/tests/test_panel_stage_b_physical_runner_contract.py') - test = test_path.read_text(encoding='utf-8') - test = test.replace( - 'from __future__ import annotations\n\nfrom dev.benchmarks.validate_panel_stage_b_gpu import (\n', - 'from __future__ import annotations\n\nimport numpy as np\nimport pytest\n\nfrom dev.benchmarks.validate_panel_stage_b_gpu import (\n', - 1, - ) - test = test.replace( - ' _dataset,\n _fit_cases,\n _model_snapshot,\n', - ' _dataset,\n _find_applicable_hausman_fixture,\n _fit_cases,\n _model_snapshot,\n _require_applicable_hausman_coverage,\n', - 1, - ) - test += ''' - - -def test_physical_runner_finds_applicable_hausman_reference_fixture(): - fixture = _find_applicable_hausman_fixture() - result = fixture["reference"] - - assert result["applicable"] is True - assert result["reason"] is None - assert result["df"] is not None and float(result["df"]) > 0.0 - assert np.isfinite(float(result["statistic"])) - assert np.isfinite(float(result["pvalue"])) - assert fixture["X"].shape[0] == fixture["y"].shape[0] - assert fixture["entity"].shape[0] == fixture["y"].shape[0] - - -def test_physical_runner_requires_applicable_hausman_per_backend(): - with pytest.raises(AssertionError, match="requires at least one applicable"): - _require_applicable_hausman_coverage( - { - "hausman_balanced": {"applicable": False}, - "hausman_unbalanced": {"applicable": False}, - }, - backend="torch", - ) - - applicable = _require_applicable_hausman_coverage( - { - "hausman_balanced": {"applicable": False}, - "hausman_applicable_physical": {"applicable": True}, - }, - backend="cupy", - ) - assert applicable == ["hausman_applicable_physical"] -''' - test_path.write_text(test, encoding='utf-8') - PY + run: python -c "import base64; exec(base64.b64decode('from pathlib import Path

runner_path = Path("dev/benchmarks/validate_panel_stage_b_gpu.py")
runner = runner_path.read_text(encoding="utf-8")

anchor = "    return cases, diagnostics\n\n\ndef _scalar_diff(actual, expected, *, rtol, atol, label):\n"
replacement = '''    return cases, diagnostics


def _hausman_applicable_dataset(seed: int):
    """Return a deterministic one-way panel suited to an applicable Hausman gate."""
    rng = np.random.default_rng(seed)
    n_entities, n_times = 32, 8
    entity = np.repeat(np.arange(n_entities), n_times)
    time = np.tile(np.arange(n_times), n_entities)
    X = rng.normal(size=(entity.size, 2))
    random_effect = np.repeat(rng.normal(scale=0.65, size=n_entities), n_times)
    y = (
        0.8 * X[:, 0]
        - 0.35 * X[:, 1]
        + random_effect
        + rng.normal(scale=0.2, size=entity.size)
    )
    return X.astype(np.float64), y.astype(np.float64), entity, time


def _find_applicable_hausman_fixture(*, start_seed=20260810, max_attempts=512):
    """Find a bounded deterministic NumPy fixture with an applicable Hausman test."""
    for seed in range(int(start_seed), int(start_seed) + int(max_attempts)):
        X, y, entity, time = _hausman_applicable_dataset(seed)
        fe = PanelOLS(entity_effects=True, cov_type="nonrobust", device="cpu").fit(
            X, y, entity_ids=entity
        )
        re = RandomEffects(device="cpu").fit(X, y, entity_ids=entity)
        result = _test_result(fe.hausman_test(re))
        if (
            result["applicable"]
            and result["statistic"] is not None
            and result["pvalue"] is not None
            and result["df"] is not None
            and np.isfinite(float(result["statistic"]))
            and np.isfinite(float(result["pvalue"]))
            and float(result["df"]) > 0.0
        ):
            return {
                "seed": int(seed),
                "X": X,
                "y": y,
                "entity": entity,
                "time": time,
                "reference": result,
            }
    raise RuntimeError(
        "unable to find an applicable Hausman fixture within the bounded seed search"
    )


def _require_applicable_hausman_coverage(diagnostics, *, backend):
    """Require at least one physically executed applicable Hausman diagnostic."""
    applicable = sorted(
        name
        for name, payload in diagnostics.items()
        if payload.get("applicable") is True
    )
    if not applicable:
        raise AssertionError(
            f"{backend}: physical Hausman gate requires at least one applicable case"
        )
    return applicable


def _scalar_diff(actual, expected, *, rtol, atol, label):
'''
if anchor not in runner:
    raise SystemExit("runner helper anchor not found")
runner = runner.replace(anchor, replacement, 1)

anchor = "        reference_diagnostics.update(diagnostics)\n\n    results = {}\n"
replacement = '''        reference_diagnostics.update(diagnostics)

    applicable_fixture = _find_applicable_hausman_fixture()
    reference_diagnostics["hausman_applicable_physical"] = applicable_fixture[
        "reference"
    ]

    results = {}
'''
if anchor not in runner:
    raise SystemExit("reference fixture anchor not found")
runner = runner.replace(anchor, replacement, 1)

anchor = "        results[backend] = backend_payload\n\n    payload = {\n"
replacement = '''        Xf = applicable_fixture["X"]
        yf = applicable_fixture["y"]
        ef = applicable_fixture["entity"]
        tf = applicable_fixture["time"]
        Xfb, yfb, efb, _ = _to_backend_arrays(Xf, yf, ef, tf, backend)
        device = _device_arg(backend)
        fe_applicable = PanelOLS(
            entity_effects=True,
            cov_type="nonrobust",
            device=device,
        ).fit(Xfb, yfb, entity_ids=efb)
        re_applicable = RandomEffects(device=device).fit(Xfb, yfb, entity_ids=efb)
        for model_name, model in (
            ("hausman_applicable_fe", fe_applicable),
            ("hausman_applicable_re", re_applicable),
        ):
            actual_backend = _backend_name(model)
            if actual_backend != backend:
                raise AssertionError(
                    f"{model_name}: requested {backend}, executed {actual_backend}"
                )

        applicable_result = _test_result(
            fe_applicable.hausman_test(re_applicable)
        )
        if not applicable_result["applicable"]:
            raise AssertionError(
                f"hausman_applicable_physical unexpectedly inapplicable on {backend}: "
                f"{applicable_result['reason']}"
            )
        differences = _compare_test_result(
            reference_diagnostics["hausman_applicable_physical"],
            applicable_result,
            rtol=args.rtol,
            atol=args.atol,
            label="hausman_applicable_physical",
        )
        backend_payload["diagnostics"]["hausman_applicable_physical"] = {
            "status": "success",
            "max_abs_differences": differences,
            "applicable": True,
            "reason": applicable_result["reason"],
            "fixture_seed": applicable_fixture["seed"],
            "nobs": int(len(yf)),
        }
        _require_applicable_hausman_coverage(
            backend_payload["diagnostics"], backend=backend
        )
        results[backend] = backend_payload

    payload = {
'''
if anchor not in runner:
    raise SystemExit("backend coverage anchor not found")
runner = runner.replace(anchor, replacement, 1)

anchor = '''        "datasets": {
            name: {"nobs": int(len(values[1]))}
            for name, values in datasets.items()
        },
'''
replacement = '''        "datasets": {
            **{
                name: {"nobs": int(len(values[1]))}
                for name, values in datasets.items()
            },
            "hausman_applicable": {
                "nobs": int(len(applicable_fixture["y"])),
                "seed": applicable_fixture["seed"],
            },
        },
'''
if anchor not in runner:
    raise SystemExit("dataset metadata anchor not found")
runner = runner.replace(anchor, replacement, 1)
runner_path.write_text(runner, encoding="utf-8")

test_path = Path("dev/tests/test_panel_stage_b_physical_runner_contract.py")
test = test_path.read_text(encoding="utf-8")
test = test.replace(
    "from __future__ import annotations\n\nfrom dev.benchmarks.validate_panel_stage_b_gpu import (\n",
    "from __future__ import annotations\n\nimport numpy as np\nimport pytest\n\nfrom dev.benchmarks.validate_panel_stage_b_gpu import (\n",
    1,
)
test = test.replace(
    "    _dataset,\n    _fit_cases,\n    _model_snapshot,\n",
    "    _dataset,\n    _find_applicable_hausman_fixture,\n    _fit_cases,\n    _model_snapshot,\n    _require_applicable_hausman_coverage,\n",
    1,
)
test += '''


def test_physical_runner_finds_applicable_hausman_reference_fixture():
    fixture = _find_applicable_hausman_fixture()
    result = fixture["reference"]

    assert result["applicable"] is True
    assert result["reason"] is None
    assert result["df"] is not None and float(result["df"]) > 0.0
    assert np.isfinite(float(result["statistic"]))
    assert np.isfinite(float(result["pvalue"]))
    assert fixture["X"].shape[0] == fixture["y"].shape[0]
    assert fixture["entity"].shape[0] == fixture["y"].shape[0]


def test_physical_runner_requires_applicable_hausman_per_backend():
    with pytest.raises(AssertionError, match="requires at least one applicable"):
        _require_applicable_hausman_coverage(
            {
                "hausman_balanced": {"applicable": False},
                "hausman_unbalanced": {"applicable": False},
            },
            backend="torch",
        )

    applicable = _require_applicable_hausman_coverage(
        {
            "hausman_balanced": {"applicable": False},
            "hausman_applicable_physical": {"applicable": True},
        },
        backend="cupy",
    )
    assert applicable == ["hausman_applicable_physical"]
'''
test_path.write_text(test, encoding="utf-8")
'))" - name: Install targeted test dependencies run: | @@ -262,7 +41,6 @@ def test_physical_runner_requires_applicable_hausman_per_backend(): git diff --check - name: Commit focused fix and remove temporary workflow - shell: bash run: | rm .github/workflows/pr122-autofix-applicable-hausman.yml git diff --check From d509018c9ece6a637c9104229e6fb70317521796 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 18:31:22 +0800 Subject: [PATCH 130/165] ci: refine PR122 applicable Hausman fixture --- .github/workflows/pr122-autofix-applicable-hausman.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/pr122-autofix-applicable-hausman.yml b/.github/workflows/pr122-autofix-applicable-hausman.yml index 999b90d20..dda122aeb 100644 --- a/.github/workflows/pr122-autofix-applicable-hausman.yml +++ b/.github/workflows/pr122-autofix-applicable-hausman.yml @@ -24,7 +24,7 @@ jobs: python-version: '3.11' - name: Patch physical Hausman coverage gate - run: python -c "import base64; exec(base64.b64decode('from pathlib import Path

runner_path = Path("dev/benchmarks/validate_panel_stage_b_gpu.py")
runner = runner_path.read_text(encoding="utf-8")

anchor = "    return cases, diagnostics\n\n\ndef _scalar_diff(actual, expected, *, rtol, atol, label):\n"
replacement = '''    return cases, diagnostics


def _hausman_applicable_dataset(seed: int):
    """Return a deterministic one-way panel suited to an applicable Hausman gate."""
    rng = np.random.default_rng(seed)
    n_entities, n_times = 32, 8
    entity = np.repeat(np.arange(n_entities), n_times)
    time = np.tile(np.arange(n_times), n_entities)
    X = rng.normal(size=(entity.size, 2))
    random_effect = np.repeat(rng.normal(scale=0.65, size=n_entities), n_times)
    y = (
        0.8 * X[:, 0]
        - 0.35 * X[:, 1]
        + random_effect
        + rng.normal(scale=0.2, size=entity.size)
    )
    return X.astype(np.float64), y.astype(np.float64), entity, time


def _find_applicable_hausman_fixture(*, start_seed=20260810, max_attempts=512):
    """Find a bounded deterministic NumPy fixture with an applicable Hausman test."""
    for seed in range(int(start_seed), int(start_seed) + int(max_attempts)):
        X, y, entity, time = _hausman_applicable_dataset(seed)
        fe = PanelOLS(entity_effects=True, cov_type="nonrobust", device="cpu").fit(
            X, y, entity_ids=entity
        )
        re = RandomEffects(device="cpu").fit(X, y, entity_ids=entity)
        result = _test_result(fe.hausman_test(re))
        if (
            result["applicable"]
            and result["statistic"] is not None
            and result["pvalue"] is not None
            and result["df"] is not None
            and np.isfinite(float(result["statistic"]))
            and np.isfinite(float(result["pvalue"]))
            and float(result["df"]) > 0.0
        ):
            return {
                "seed": int(seed),
                "X": X,
                "y": y,
                "entity": entity,
                "time": time,
                "reference": result,
            }
    raise RuntimeError(
        "unable to find an applicable Hausman fixture within the bounded seed search"
    )


def _require_applicable_hausman_coverage(diagnostics, *, backend):
    """Require at least one physically executed applicable Hausman diagnostic."""
    applicable = sorted(
        name
        for name, payload in diagnostics.items()
        if payload.get("applicable") is True
    )
    if not applicable:
        raise AssertionError(
            f"{backend}: physical Hausman gate requires at least one applicable case"
        )
    return applicable


def _scalar_diff(actual, expected, *, rtol, atol, label):
'''
if anchor not in runner:
    raise SystemExit("runner helper anchor not found")
runner = runner.replace(anchor, replacement, 1)

anchor = "        reference_diagnostics.update(diagnostics)\n\n    results = {}\n"
replacement = '''        reference_diagnostics.update(diagnostics)

    applicable_fixture = _find_applicable_hausman_fixture()
    reference_diagnostics["hausman_applicable_physical"] = applicable_fixture[
        "reference"
    ]

    results = {}
'''
if anchor not in runner:
    raise SystemExit("reference fixture anchor not found")
runner = runner.replace(anchor, replacement, 1)

anchor = "        results[backend] = backend_payload\n\n    payload = {\n"
replacement = '''        Xf = applicable_fixture["X"]
        yf = applicable_fixture["y"]
        ef = applicable_fixture["entity"]
        tf = applicable_fixture["time"]
        Xfb, yfb, efb, _ = _to_backend_arrays(Xf, yf, ef, tf, backend)
        device = _device_arg(backend)
        fe_applicable = PanelOLS(
            entity_effects=True,
            cov_type="nonrobust",
            device=device,
        ).fit(Xfb, yfb, entity_ids=efb)
        re_applicable = RandomEffects(device=device).fit(Xfb, yfb, entity_ids=efb)
        for model_name, model in (
            ("hausman_applicable_fe", fe_applicable),
            ("hausman_applicable_re", re_applicable),
        ):
            actual_backend = _backend_name(model)
            if actual_backend != backend:
                raise AssertionError(
                    f"{model_name}: requested {backend}, executed {actual_backend}"
                )

        applicable_result = _test_result(
            fe_applicable.hausman_test(re_applicable)
        )
        if not applicable_result["applicable"]:
            raise AssertionError(
                f"hausman_applicable_physical unexpectedly inapplicable on {backend}: "
                f"{applicable_result['reason']}"
            )
        differences = _compare_test_result(
            reference_diagnostics["hausman_applicable_physical"],
            applicable_result,
            rtol=args.rtol,
            atol=args.atol,
            label="hausman_applicable_physical",
        )
        backend_payload["diagnostics"]["hausman_applicable_physical"] = {
            "status": "success",
            "max_abs_differences": differences,
            "applicable": True,
            "reason": applicable_result["reason"],
            "fixture_seed": applicable_fixture["seed"],
            "nobs": int(len(yf)),
        }
        _require_applicable_hausman_coverage(
            backend_payload["diagnostics"], backend=backend
        )
        results[backend] = backend_payload

    payload = {
'''
if anchor not in runner:
    raise SystemExit("backend coverage anchor not found")
runner = runner.replace(anchor, replacement, 1)

anchor = '''        "datasets": {
            name: {"nobs": int(len(values[1]))}
            for name, values in datasets.items()
        },
'''
replacement = '''        "datasets": {
            **{
                name: {"nobs": int(len(values[1]))}
                for name, values in datasets.items()
            },
            "hausman_applicable": {
                "nobs": int(len(applicable_fixture["y"])),
                "seed": applicable_fixture["seed"],
            },
        },
'''
if anchor not in runner:
    raise SystemExit("dataset metadata anchor not found")
runner = runner.replace(anchor, replacement, 1)
runner_path.write_text(runner, encoding="utf-8")

test_path = Path("dev/tests/test_panel_stage_b_physical_runner_contract.py")
test = test_path.read_text(encoding="utf-8")
test = test.replace(
    "from __future__ import annotations\n\nfrom dev.benchmarks.validate_panel_stage_b_gpu import (\n",
    "from __future__ import annotations\n\nimport numpy as np\nimport pytest\n\nfrom dev.benchmarks.validate_panel_stage_b_gpu import (\n",
    1,
)
test = test.replace(
    "    _dataset,\n    _fit_cases,\n    _model_snapshot,\n",
    "    _dataset,\n    _find_applicable_hausman_fixture,\n    _fit_cases,\n    _model_snapshot,\n    _require_applicable_hausman_coverage,\n",
    1,
)
test += '''


def test_physical_runner_finds_applicable_hausman_reference_fixture():
    fixture = _find_applicable_hausman_fixture()
    result = fixture["reference"]

    assert result["applicable"] is True
    assert result["reason"] is None
    assert result["df"] is not None and float(result["df"]) > 0.0
    assert np.isfinite(float(result["statistic"]))
    assert np.isfinite(float(result["pvalue"]))
    assert fixture["X"].shape[0] == fixture["y"].shape[0]
    assert fixture["entity"].shape[0] == fixture["y"].shape[0]


def test_physical_runner_requires_applicable_hausman_per_backend():
    with pytest.raises(AssertionError, match="requires at least one applicable"):
        _require_applicable_hausman_coverage(
            {
                "hausman_balanced": {"applicable": False},
                "hausman_unbalanced": {"applicable": False},
            },
            backend="torch",
        )

    applicable = _require_applicable_hausman_coverage(
        {
            "hausman_balanced": {"applicable": False},
            "hausman_applicable_physical": {"applicable": True},
        },
        backend="cupy",
    )
    assert applicable == ["hausman_applicable_physical"]
'''
test_path.write_text(test, encoding="utf-8")
'))" + run: python -c "import base64; exec(base64.b64decode('
from pathlib import Path

runner_path = Path("dev/benchmarks/validate_panel_stage_b_gpu.py")
runner = runner_path.read_text(encoding="utf-8")

anchor = "    return cases, diagnostics\n\n\ndef _scalar_diff(actual, expected, *, rtol, atol, label):\n"
replacement = '''    return cases, diagnostics


def _hausman_applicable_dataset(seed: int):
    \'\'\'Return a deterministic one-slope panel for the applicable Hausman gate.\'\'\'
    rng = np.random.default_rng(seed)
    n_entities, n_times = 32, 8
    entity = np.repeat(np.arange(n_entities), n_times)
    time = np.tile(np.arange(n_times), n_entities)
    X = rng.normal(size=(entity.size, 1))
    random_effect = np.repeat(rng.normal(scale=0.65, size=n_entities), n_times)
    y = (
        0.8 * X[:, 0]
        + random_effect
        + rng.normal(scale=0.2, size=entity.size)
    )
    return X.astype(np.float64), y.astype(np.float64), entity, time


def _find_applicable_hausman_fixture(*, start_seed=20260810, max_attempts=256):
    \'\'\'Find a bounded deterministic fitted FE/RE fixture with applicable Hausman.\'\'\'
    best = None
    for seed in range(int(start_seed), int(start_seed) + int(max_attempts)):
        X, y, entity, time = _hausman_applicable_dataset(seed)
        fe = PanelOLS(entity_effects=True, cov_type="nonrobust", device="cpu").fit(
            X, y, entity_ids=entity
        )
        re = RandomEffects(device="cpu").fit(X, y, entity_ids=entity)
        result = _test_result(fe.hausman_test(re))
        variance_difference = float(
            np.asarray(fe._panel_cov_params, dtype=np.float64)[0, 0]
            - np.asarray(re._panel_cov_params, dtype=np.float64)[0, 0]
        )
        if best is None or variance_difference > best["variance_difference"]:
            best = {
                "seed": int(seed),
                "variance_difference": variance_difference,
                "reason": result["reason"],
            }
        if (
            result["applicable"]
            and result["statistic"] is not None
            and result["pvalue"] is not None
            and result["df"] is not None
            and np.isfinite(float(result["statistic"]))
            and np.isfinite(float(result["pvalue"]))
            and float(result["df"]) > 0.0
        ):
            return {
                "seed": int(seed),
                "X": X,
                "y": y,
                "entity": entity,
                "time": time,
                "reference": result,
                "variance_difference": variance_difference,
            }
    raise RuntimeError(
        "unable to find an applicable Hausman fixture within the bounded seed search; "
        f"best={best}"
    )


def _require_applicable_hausman_coverage(diagnostics, *, backend):
    \'\'\'Require at least one physically executed applicable Hausman diagnostic.\'\'\'
    applicable = sorted(
        name
        for name, payload in diagnostics.items()
        if payload.get("applicable") is True
    )
    if not applicable:
        raise AssertionError(
            f"{backend}: physical Hausman gate requires at least one applicable case"
        )
    return applicable


def _scalar_diff(actual, expected, *, rtol, atol, label):
'''
if anchor not in runner:
    raise SystemExit("runner helper anchor not found")
runner = runner.replace(anchor, replacement, 1)

anchor = "        reference_diagnostics.update(diagnostics)\n\n    results = {}\n"
replacement = '''        reference_diagnostics.update(diagnostics)

    applicable_fixture = _find_applicable_hausman_fixture()
    reference_diagnostics["hausman_applicable_physical"] = applicable_fixture[
        "reference"
    ]

    results = {}
'''
if anchor not in runner:
    raise SystemExit("reference fixture anchor not found")
runner = runner.replace(anchor, replacement, 1)

anchor = "        results[backend] = backend_payload\n\n    payload = {\n"
replacement = '''        Xf = applicable_fixture["X"]
        yf = applicable_fixture["y"]
        ef = applicable_fixture["entity"]
        tf = applicable_fixture["time"]
        Xfb, yfb, efb, _ = _to_backend_arrays(Xf, yf, ef, tf, backend)
        device = _device_arg(backend)
        fe_applicable = PanelOLS(
            entity_effects=True,
            cov_type="nonrobust",
            device=device,
        ).fit(Xfb, yfb, entity_ids=efb)
        re_applicable = RandomEffects(device=device).fit(Xfb, yfb, entity_ids=efb)
        for model_name, model in (
            ("hausman_applicable_fe", fe_applicable),
            ("hausman_applicable_re", re_applicable),
        ):
            actual_backend = _backend_name(model)
            if actual_backend != backend:
                raise AssertionError(
                    f"{model_name}: requested {backend}, executed {actual_backend}"
                )

        applicable_result = _test_result(
            fe_applicable.hausman_test(re_applicable)
        )
        if not applicable_result["applicable"]:
            raise AssertionError(
                f"hausman_applicable_physical unexpectedly inapplicable on {backend}: "
                f"{applicable_result['reason']}"
            )
        differences = _compare_test_result(
            reference_diagnostics["hausman_applicable_physical"],
            applicable_result,
            rtol=args.rtol,
            atol=args.atol,
            label="hausman_applicable_physical",
        )
        backend_payload["diagnostics"]["hausman_applicable_physical"] = {
            "status": "success",
            "max_abs_differences": differences,
            "applicable": True,
            "reason": applicable_result["reason"],
            "fixture_seed": applicable_fixture["seed"],
            "nobs": int(len(yf)),
            "variance_difference": applicable_fixture["variance_difference"],
        }
        _require_applicable_hausman_coverage(
            backend_payload["diagnostics"], backend=backend
        )
        results[backend] = backend_payload

    payload = {
'''
if anchor not in runner:
    raise SystemExit("backend coverage anchor not found")
runner = runner.replace(anchor, replacement, 1)

anchor = '''        "datasets": {
            name: {"nobs": int(len(values[1]))}
            for name, values in datasets.items()
        },
'''
replacement = '''        "datasets": {
            **{
                name: {"nobs": int(len(values[1]))}
                for name, values in datasets.items()
            },
            "hausman_applicable": {
                "nobs": int(len(applicable_fixture["y"])),
                "seed": applicable_fixture["seed"],
                "variance_difference": applicable_fixture["variance_difference"],
            },
        },
'''
if anchor not in runner:
    raise SystemExit("dataset metadata anchor not found")
runner = runner.replace(anchor, replacement, 1)
runner_path.write_text(runner, encoding="utf-8")

test_path = Path("dev/tests/test_panel_stage_b_physical_runner_contract.py")
test = test_path.read_text(encoding="utf-8")
test = test.replace(
    "from __future__ import annotations\n\nfrom dev.benchmarks.validate_panel_stage_b_gpu import (\n",
    "from __future__ import annotations\n\nimport numpy as np\nimport pytest\n\nfrom dev.benchmarks.validate_panel_stage_b_gpu import (\n",
    1,
)
test = test.replace(
    "    _dataset,\n    _fit_cases,\n    _model_snapshot,\n",
    "    _dataset,\n    _find_applicable_hausman_fixture,\n    _fit_cases,\n    _model_snapshot,\n    _require_applicable_hausman_coverage,\n",
    1,
)
test += '''


def test_physical_runner_finds_applicable_hausman_reference_fixture():
    fixture = _find_applicable_hausman_fixture()
    result = fixture["reference"]

    assert result["applicable"] is True
    assert result["reason"] is None
    assert result["df"] == 1.0
    assert np.isfinite(float(result["statistic"]))
    assert np.isfinite(float(result["pvalue"]))
    assert fixture["variance_difference"] > 0.0
    assert fixture["X"].shape[1] == 1
    assert fixture["X"].shape[0] == fixture["y"].shape[0]
    assert fixture["entity"].shape[0] == fixture["y"].shape[0]


def test_physical_runner_requires_applicable_hausman_per_backend():
    with pytest.raises(AssertionError, match="requires at least one applicable"):
        _require_applicable_hausman_coverage(
            {
                "hausman_balanced": {"applicable": False},
                "hausman_unbalanced": {"applicable": False},
            },
            backend="torch",
        )

    applicable = _require_applicable_hausman_coverage(
        {
            "hausman_balanced": {"applicable": False},
            "hausman_applicable_physical": {"applicable": True},
        },
        backend="cupy",
    )
    assert applicable == ["hausman_applicable_physical"]
'''
test_path.write_text(test, encoding="utf-8")
'))" - name: Install targeted test dependencies run: | From e188641698ed0e3c9a03ae49f69f8356cdae6844 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 18:32:27 +0800 Subject: [PATCH 131/165] ci: scan applicable Hausman fixture regimes --- .../pr122-autofix-applicable-hausman.yml | 82 +++++++++++++------ 1 file changed, 57 insertions(+), 25 deletions(-) diff --git a/.github/workflows/pr122-autofix-applicable-hausman.yml b/.github/workflows/pr122-autofix-applicable-hausman.yml index dda122aeb..b1f573dcc 100644 --- a/.github/workflows/pr122-autofix-applicable-hausman.yml +++ b/.github/workflows/pr122-autofix-applicable-hausman.yml @@ -11,7 +11,7 @@ permissions: contents: write jobs: - autofix: + scan: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 @@ -23,31 +23,63 @@ jobs: with: python-version: '3.11' - - name: Patch physical Hausman coverage gate - run: python -c "import base64; exec(base64.b64decode('
from pathlib import Path

runner_path = Path("dev/benchmarks/validate_panel_stage_b_gpu.py")
runner = runner_path.read_text(encoding="utf-8")

anchor = "    return cases, diagnostics\n\n\ndef _scalar_diff(actual, expected, *, rtol, atol, label):\n"
replacement = '''    return cases, diagnostics


def _hausman_applicable_dataset(seed: int):
    \'\'\'Return a deterministic one-slope panel for the applicable Hausman gate.\'\'\'
    rng = np.random.default_rng(seed)
    n_entities, n_times = 32, 8
    entity = np.repeat(np.arange(n_entities), n_times)
    time = np.tile(np.arange(n_times), n_entities)
    X = rng.normal(size=(entity.size, 1))
    random_effect = np.repeat(rng.normal(scale=0.65, size=n_entities), n_times)
    y = (
        0.8 * X[:, 0]
        + random_effect
        + rng.normal(scale=0.2, size=entity.size)
    )
    return X.astype(np.float64), y.astype(np.float64), entity, time


def _find_applicable_hausman_fixture(*, start_seed=20260810, max_attempts=256):
    \'\'\'Find a bounded deterministic fitted FE/RE fixture with applicable Hausman.\'\'\'
    best = None
    for seed in range(int(start_seed), int(start_seed) + int(max_attempts)):
        X, y, entity, time = _hausman_applicable_dataset(seed)
        fe = PanelOLS(entity_effects=True, cov_type="nonrobust", device="cpu").fit(
            X, y, entity_ids=entity
        )
        re = RandomEffects(device="cpu").fit(X, y, entity_ids=entity)
        result = _test_result(fe.hausman_test(re))
        variance_difference = float(
            np.asarray(fe._panel_cov_params, dtype=np.float64)[0, 0]
            - np.asarray(re._panel_cov_params, dtype=np.float64)[0, 0]
        )
        if best is None or variance_difference > best["variance_difference"]:
            best = {
                "seed": int(seed),
                "variance_difference": variance_difference,
                "reason": result["reason"],
            }
        if (
            result["applicable"]
            and result["statistic"] is not None
            and result["pvalue"] is not None
            and result["df"] is not None
            and np.isfinite(float(result["statistic"]))
            and np.isfinite(float(result["pvalue"]))
            and float(result["df"]) > 0.0
        ):
            return {
                "seed": int(seed),
                "X": X,
                "y": y,
                "entity": entity,
                "time": time,
                "reference": result,
                "variance_difference": variance_difference,
            }
    raise RuntimeError(
        "unable to find an applicable Hausman fixture within the bounded seed search; "
        f"best={best}"
    )


def _require_applicable_hausman_coverage(diagnostics, *, backend):
    \'\'\'Require at least one physically executed applicable Hausman diagnostic.\'\'\'
    applicable = sorted(
        name
        for name, payload in diagnostics.items()
        if payload.get("applicable") is True
    )
    if not applicable:
        raise AssertionError(
            f"{backend}: physical Hausman gate requires at least one applicable case"
        )
    return applicable


def _scalar_diff(actual, expected, *, rtol, atol, label):
'''
if anchor not in runner:
    raise SystemExit("runner helper anchor not found")
runner = runner.replace(anchor, replacement, 1)

anchor = "        reference_diagnostics.update(diagnostics)\n\n    results = {}\n"
replacement = '''        reference_diagnostics.update(diagnostics)

    applicable_fixture = _find_applicable_hausman_fixture()
    reference_diagnostics["hausman_applicable_physical"] = applicable_fixture[
        "reference"
    ]

    results = {}
'''
if anchor not in runner:
    raise SystemExit("reference fixture anchor not found")
runner = runner.replace(anchor, replacement, 1)

anchor = "        results[backend] = backend_payload\n\n    payload = {\n"
replacement = '''        Xf = applicable_fixture["X"]
        yf = applicable_fixture["y"]
        ef = applicable_fixture["entity"]
        tf = applicable_fixture["time"]
        Xfb, yfb, efb, _ = _to_backend_arrays(Xf, yf, ef, tf, backend)
        device = _device_arg(backend)
        fe_applicable = PanelOLS(
            entity_effects=True,
            cov_type="nonrobust",
            device=device,
        ).fit(Xfb, yfb, entity_ids=efb)
        re_applicable = RandomEffects(device=device).fit(Xfb, yfb, entity_ids=efb)
        for model_name, model in (
            ("hausman_applicable_fe", fe_applicable),
            ("hausman_applicable_re", re_applicable),
        ):
            actual_backend = _backend_name(model)
            if actual_backend != backend:
                raise AssertionError(
                    f"{model_name}: requested {backend}, executed {actual_backend}"
                )

        applicable_result = _test_result(
            fe_applicable.hausman_test(re_applicable)
        )
        if not applicable_result["applicable"]:
            raise AssertionError(
                f"hausman_applicable_physical unexpectedly inapplicable on {backend}: "
                f"{applicable_result['reason']}"
            )
        differences = _compare_test_result(
            reference_diagnostics["hausman_applicable_physical"],
            applicable_result,
            rtol=args.rtol,
            atol=args.atol,
            label="hausman_applicable_physical",
        )
        backend_payload["diagnostics"]["hausman_applicable_physical"] = {
            "status": "success",
            "max_abs_differences": differences,
            "applicable": True,
            "reason": applicable_result["reason"],
            "fixture_seed": applicable_fixture["seed"],
            "nobs": int(len(yf)),
            "variance_difference": applicable_fixture["variance_difference"],
        }
        _require_applicable_hausman_coverage(
            backend_payload["diagnostics"], backend=backend
        )
        results[backend] = backend_payload

    payload = {
'''
if anchor not in runner:
    raise SystemExit("backend coverage anchor not found")
runner = runner.replace(anchor, replacement, 1)

anchor = '''        "datasets": {
            name: {"nobs": int(len(values[1]))}
            for name, values in datasets.items()
        },
'''
replacement = '''        "datasets": {
            **{
                name: {"nobs": int(len(values[1]))}
                for name, values in datasets.items()
            },
            "hausman_applicable": {
                "nobs": int(len(applicable_fixture["y"])),
                "seed": applicable_fixture["seed"],
                "variance_difference": applicable_fixture["variance_difference"],
            },
        },
'''
if anchor not in runner:
    raise SystemExit("dataset metadata anchor not found")
runner = runner.replace(anchor, replacement, 1)
runner_path.write_text(runner, encoding="utf-8")

test_path = Path("dev/tests/test_panel_stage_b_physical_runner_contract.py")
test = test_path.read_text(encoding="utf-8")
test = test.replace(
    "from __future__ import annotations\n\nfrom dev.benchmarks.validate_panel_stage_b_gpu import (\n",
    "from __future__ import annotations\n\nimport numpy as np\nimport pytest\n\nfrom dev.benchmarks.validate_panel_stage_b_gpu import (\n",
    1,
)
test = test.replace(
    "    _dataset,\n    _fit_cases,\n    _model_snapshot,\n",
    "    _dataset,\n    _find_applicable_hausman_fixture,\n    _fit_cases,\n    _model_snapshot,\n    _require_applicable_hausman_coverage,\n",
    1,
)
test += '''


def test_physical_runner_finds_applicable_hausman_reference_fixture():
    fixture = _find_applicable_hausman_fixture()
    result = fixture["reference"]

    assert result["applicable"] is True
    assert result["reason"] is None
    assert result["df"] == 1.0
    assert np.isfinite(float(result["statistic"]))
    assert np.isfinite(float(result["pvalue"]))
    assert fixture["variance_difference"] > 0.0
    assert fixture["X"].shape[1] == 1
    assert fixture["X"].shape[0] == fixture["y"].shape[0]
    assert fixture["entity"].shape[0] == fixture["y"].shape[0]


def test_physical_runner_requires_applicable_hausman_per_backend():
    with pytest.raises(AssertionError, match="requires at least one applicable"):
        _require_applicable_hausman_coverage(
            {
                "hausman_balanced": {"applicable": False},
                "hausman_unbalanced": {"applicable": False},
            },
            backend="torch",
        )

    applicable = _require_applicable_hausman_coverage(
        {
            "hausman_balanced": {"applicable": False},
            "hausman_applicable_physical": {"applicable": True},
        },
        backend="cupy",
    )
    assert applicable == ["hausman_applicable_physical"]
'''
test_path.write_text(test, encoding="utf-8")
'))" - - - name: Install targeted test dependencies + - name: Install dependencies run: | - python -m pip install --upgrade pip - python -m pip install -e . pytest + python -m pip install -e . - - name: Run targeted Stage-B review gates + - name: Scan fitted Hausman regimes run: | - python -m pytest -q \ - dev/tests/test_panel_stage_b_physical_runner_contract.py \ - dev/tests/test_panel_stage_b_diagnostics.py \ - dev/tests/test_panel_stage_b_hausman_covariance.py \ - dev/tests/test_panel_stage_b_review_regressions.py - git diff --check + python - <<'PY' + import numpy as np + from statgpu.panel import PanelOLS, RandomEffects - - name: Commit focused fix and remove temporary workflow - run: | - rm .github/workflows/pr122-autofix-applicable-hausman.yml - git diff --check - git config user.name 'github-actions[bot]' - git config user.email '41898282+github-actions[bot]@users.noreply.github.com' - git add dev/benchmarks/validate_panel_stage_b_gpu.py \ - dev/tests/test_panel_stage_b_physical_runner_contract.py \ - .github/workflows/pr122-autofix-applicable-hausman.yml - git commit -m 'test: require applicable Hausman GPU coverage' - git push origin HEAD:agent/panel-p1-stage-b-diagnostics + best = None + for n_entities in (12, 24, 32, 48): + for n_times in (4, 6, 8, 12): + entity = np.repeat(np.arange(n_entities), n_times) + for effect_scale in (0.0, 0.01, 0.03, 0.08, 0.2, 0.5): + for noise_scale in (0.1, 0.2, 0.5, 1.0): + for seed in range(20260810, 20260850): + rng = np.random.default_rng(seed) + X = rng.normal(size=(entity.size, 1)) + alpha = np.repeat( + rng.normal(scale=effect_scale, size=n_entities), + n_times, + ) + y = 0.8 * X[:, 0] + alpha + rng.normal( + scale=noise_scale, size=entity.size + ) + fe = PanelOLS( + entity_effects=True, + cov_type='nonrobust', + device='cpu', + ).fit(X, y, entity_ids=entity) + re = RandomEffects(device='cpu').fit( + X, y, entity_ids=entity + ) + result = fe.hausman_test(re) + dvar = float( + np.asarray(fe._panel_cov_params)[0, 0] + - np.asarray(re._panel_cov_params)[0, 0] + ) + candidate = ( + dvar, + n_entities, + n_times, + effect_scale, + noise_scale, + seed, + result.applicable, + result.statistic, + result.pvalue, + result.df, + result.reason, + ) + if best is None or dvar > best[0]: + best = candidate + if result.applicable: + print('FOUND', candidate) + raise SystemExit(0) + print('BEST', best) + raise SystemExit('no applicable fitted Hausman fixture found') + PY From a9206a61a1c1f2c6b91e29657a8a8066d1a6f5f9 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 18:33:29 +0800 Subject: [PATCH 132/165] ci: scan nonzero-effect Hausman fixtures --- .../pr122-autofix-applicable-hausman.yml | 31 ++++++------------- 1 file changed, 10 insertions(+), 21 deletions(-) diff --git a/.github/workflows/pr122-autofix-applicable-hausman.yml b/.github/workflows/pr122-autofix-applicable-hausman.yml index b1f573dcc..c7d7de617 100644 --- a/.github/workflows/pr122-autofix-applicable-hausman.yml +++ b/.github/workflows/pr122-autofix-applicable-hausman.yml @@ -18,16 +18,12 @@ jobs: with: ref: agent/panel-p1-stage-b-diagnostics fetch-depth: 0 - - uses: actions/setup-python@v5 with: python-version: '3.11' - - name: Install dependencies - run: | - python -m pip install -e . - - - name: Scan fitted Hausman regimes + run: python -m pip install -e . + - name: Scan nonzero-effect fitted Hausman regimes run: | python - <<'PY' import numpy as np @@ -37,9 +33,9 @@ jobs: for n_entities in (12, 24, 32, 48): for n_times in (4, 6, 8, 12): entity = np.repeat(np.arange(n_entities), n_times) - for effect_scale in (0.0, 0.01, 0.03, 0.08, 0.2, 0.5): + for effect_scale in (0.005, 0.01, 0.03, 0.08, 0.2, 0.5): for noise_scale in (0.1, 0.2, 0.5, 1.0): - for seed in range(20260810, 20260850): + for seed in range(20260810, 20260870): rng = np.random.default_rng(seed) X = rng.normal(size=(entity.size, 1)) alpha = np.repeat( @@ -63,23 +59,16 @@ jobs: - np.asarray(re._panel_cov_params)[0, 0] ) candidate = ( - dvar, - n_entities, - n_times, - effect_scale, - noise_scale, - seed, - result.applicable, - result.statistic, - result.pvalue, - result.df, + dvar, n_entities, n_times, effect_scale, + noise_scale, seed, result.applicable, + result.statistic, result.pvalue, result.df, result.reason, ) if best is None or dvar > best[0]: best = candidate if result.applicable: - print('FOUND', candidate) + print('FOUND_NONZERO', candidate) raise SystemExit(0) - print('BEST', best) - raise SystemExit('no applicable fitted Hausman fixture found') + print('BEST_NONZERO', best) + raise SystemExit('no nonzero-effect applicable fitted Hausman fixture found') PY From 9466efa78a638f73e997d109f009b8420f2c67b1 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 18:37:20 +0800 Subject: [PATCH 133/165] ci: validate final PR122 Hausman physical gate fix --- .../pr122-autofix-applicable-hausman.yml | 81 +++++++------------ 1 file changed, 30 insertions(+), 51 deletions(-) diff --git a/.github/workflows/pr122-autofix-applicable-hausman.yml b/.github/workflows/pr122-autofix-applicable-hausman.yml index c7d7de617..177abe5f4 100644 --- a/.github/workflows/pr122-autofix-applicable-hausman.yml +++ b/.github/workflows/pr122-autofix-applicable-hausman.yml @@ -11,64 +11,43 @@ permissions: contents: write jobs: - scan: + autofix: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 with: ref: agent/panel-p1-stage-b-diagnostics fetch-depth: 0 + - uses: actions/setup-python@v5 with: - python-version: '3.11' - - name: Install dependencies - run: python -m pip install -e . - - name: Scan nonzero-effect fitted Hausman regimes + python-version: '3.9' + + - name: Apply focused Hausman physical gate patch + run: python -c "import base64; exec(base64.b64decode('
from pathlib import Path

runner_path = Path("dev/benchmarks/validate_panel_stage_b_gpu.py")
runner = runner_path.read_text(encoding="utf-8")

anchor = "    return cases, diagnostics\n\n\ndef _scalar_diff(actual, expected, *, rtol, atol, label):\n"
replacement = '''    return cases, diagnostics


def _hausman_applicable_dataset():
    \'\'\'Deterministic nonzero-effect panel with an applicable fitted Hausman test.\'\'\'
    seed = 20260810
    n_entities, n_times = 12, 4
    effect_scale, noise_scale = 0.005, 0.1
    rng = np.random.default_rng(seed)
    entity = np.repeat(np.arange(n_entities), n_times)
    time = np.tile(np.arange(n_times), n_entities)
    X = rng.normal(size=(entity.size, 1))
    entity_effect = np.repeat(
        rng.normal(scale=effect_scale, size=n_entities),
        n_times,
    )
    y = (
        0.8 * X[:, 0]
        + entity_effect
        + rng.normal(scale=noise_scale, size=entity.size)
    )
    metadata = {
        "seed": seed,
        "n_entities": n_entities,
        "n_times": n_times,
        "entity_effect_scale": effect_scale,
        "noise_scale": noise_scale,
    }
    return X.astype(np.float64), y.astype(np.float64), entity, time, metadata


def _require_applicable_hausman_coverage(diagnostics, *, backend):
    \'\'\'Require a successful applicable Hausman statistic/p-value per backend.\'\'\'
    applicable = []
    for name, payload in diagnostics.items():
        if payload.get("status") != "success" or payload.get("applicable") is not True:
            continue
        statistic = payload.get("statistic")
        pvalue = payload.get("pvalue")
        df = payload.get("df")
        if statistic is None or pvalue is None or df is None:
            continue
        if not (
            np.isfinite(float(statistic))
            and np.isfinite(float(pvalue))
            and np.isfinite(float(df))
            and float(df) > 0.0
        ):
            continue
        applicable.append(name)
    if not applicable:
        raise AssertionError(
            f"{backend}: physical Hausman gate requires at least one successful "
            "applicable statistic/pvalue/df case"
        )
    return sorted(applicable)


def _scalar_diff(actual, expected, *, rtol, atol, label):
'''
if anchor not in runner:
    raise SystemExit("runner helper anchor not found")
runner = runner.replace(anchor, replacement, 1)

anchor = "        reference_diagnostics.update(diagnostics)\n\n    results = {}\n"
replacement = '''        reference_diagnostics.update(diagnostics)

    (
        hausman_X,
        hausman_y,
        hausman_entity,
        hausman_time,
        hausman_fixture_metadata,
    ) = _hausman_applicable_dataset()
    hausman_fe_reference = PanelOLS(
        entity_effects=True,
        cov_type="nonrobust",
        device="cpu",
    ).fit(hausman_X, hausman_y, entity_ids=hausman_entity)
    hausman_re_reference = RandomEffects(device="cpu").fit(
        hausman_X, hausman_y, entity_ids=hausman_entity
    )
    hausman_reference = _test_result(
        hausman_fe_reference.hausman_test(hausman_re_reference)
    )
    hausman_variance_difference = float(
        np.asarray(hausman_fe_reference._panel_cov_params, dtype=np.float64)[0, 0]
        - np.asarray(hausman_re_reference._panel_cov_params, dtype=np.float64)[0, 0]
    )
    if not hausman_reference["applicable"]:
        raise AssertionError(
            "hosted reference Hausman fixture must remain applicable: "
            f"{hausman_reference['reason']}"
        )
    if hausman_variance_difference <= 1e-6:
        raise AssertionError(
            "hosted reference Hausman covariance-difference margin is too small: "
            f"{hausman_variance_difference}"
        )
    reference_diagnostics["hausman_applicable_nonzero_effect"] = hausman_reference

    results = {}
'''
if anchor not in runner:
    raise SystemExit("reference fixture anchor not found")
runner = runner.replace(anchor, replacement, 1)

anchor = "        results[backend] = backend_payload\n\n    payload = {\n"
replacement = '''        Xhb, yhb, ehb, _ = _to_backend_arrays(
            hausman_X,
            hausman_y,
            hausman_entity,
            hausman_time,
            backend,
        )
        device = _device_arg(backend)
        hausman_fe = PanelOLS(
            entity_effects=True,
            cov_type="nonrobust",
            device=device,
        ).fit(Xhb, yhb, entity_ids=ehb)
        hausman_re = RandomEffects(device=device).fit(Xhb, yhb, entity_ids=ehb)
        for model_name, model in (
            ("hausman_applicable_fe", hausman_fe),
            ("hausman_applicable_re", hausman_re),
        ):
            actual_backend = _backend_name(model)
            if actual_backend != backend:
                raise AssertionError(
                    f"{model_name}: requested {backend}, executed {actual_backend}"
                )

        hausman_result = _test_result(hausman_fe.hausman_test(hausman_re))
        if not hausman_result["applicable"]:
            raise AssertionError(
                f"hausman_applicable_nonzero_effect unexpectedly inapplicable on "
                f"{backend}: {hausman_result['reason']}"
            )
        hausman_differences = _compare_test_result(
            reference_diagnostics["hausman_applicable_nonzero_effect"],
            hausman_result,
            rtol=args.rtol,
            atol=args.atol,
            label="hausman_applicable_nonzero_effect",
        )
        fe_coef = _array(hausman_fe.coef_).ravel()
        re_coef = _array(hausman_re.coef_).ravel()
        fe_cov = _array(hausman_fe._panel_cov_params)
        re_cov = _array(hausman_re._panel_cov_params)
        np.testing.assert_allclose(
            fe_coef,
            _array(hausman_fe_reference.coef_).ravel(),
            rtol=args.rtol,
            atol=args.atol,
            err_msg="hausman_applicable_nonzero_effect.fe_coef",
        )
        np.testing.assert_allclose(
            re_coef,
            _array(hausman_re_reference.coef_).ravel(),
            rtol=args.rtol,
            atol=args.atol,
            err_msg="hausman_applicable_nonzero_effect.re_coef",
        )
        np.testing.assert_allclose(
            fe_cov,
            _array(hausman_fe_reference._panel_cov_params),
            rtol=args.rtol,
            atol=args.atol,
            err_msg="hausman_applicable_nonzero_effect.fe_covariance",
        )
        np.testing.assert_allclose(
            re_cov,
            _array(hausman_re_reference._panel_cov_params),
            rtol=args.rtol,
            atol=args.atol,
            err_msg="hausman_applicable_nonzero_effect.re_covariance",
        )
        backend_payload["diagnostics"]["hausman_applicable_nonzero_effect"] = {
            "status": "success",
            "max_abs_differences": hausman_differences,
            "fit_max_abs_differences": {
                "fe_coef": _max_abs_difference(
                    fe_coef, _array(hausman_fe_reference.coef_).ravel()
                ),
                "re_coef": _max_abs_difference(
                    re_coef, _array(hausman_re_reference.coef_).ravel()
                ),
                "fe_covariance": _max_abs_difference(
                    fe_cov, _array(hausman_fe_reference._panel_cov_params)
                ),
                "re_covariance": _max_abs_difference(
                    re_cov, _array(hausman_re_reference._panel_cov_params)
                ),
            },
            "applicable": True,
            "reason": hausman_result["reason"],
            "statistic": hausman_result["statistic"],
            "pvalue": hausman_result["pvalue"],
            "df": hausman_result["df"],
            "reference_statistic": hausman_reference["statistic"],
            "reference_pvalue": hausman_reference["pvalue"],
            "reference_df": hausman_reference["df"],
            "reference_variance_difference": hausman_variance_difference,
            "fixture": dict(hausman_fixture_metadata),
        }
        _require_applicable_hausman_coverage(
            backend_payload["diagnostics"], backend=backend
        )
        results[backend] = backend_payload

    payload = {
'''
if anchor not in runner:
    raise SystemExit("backend coverage anchor not found")
runner = runner.replace(anchor, replacement, 1)

anchor = '''        "datasets": {
            name: {"nobs": int(len(values[1]))}
            for name, values in datasets.items()
        },
'''
replacement = '''        "datasets": {
            **{
                name: {"nobs": int(len(values[1]))}
                for name, values in datasets.items()
            },
            "hausman_applicable_nonzero_effect": {
                "nobs": int(len(hausman_y)),
                **dict(hausman_fixture_metadata),
                "reference_variance_difference": hausman_variance_difference,
            },
        },
'''
if anchor not in runner:
    raise SystemExit("dataset metadata anchor not found")
runner = runner.replace(anchor, replacement, 1)
runner_path.write_text(runner, encoding="utf-8")

test_path = Path("dev/tests/test_panel_stage_b_physical_runner_contract.py")
test = test_path.read_text(encoding="utf-8")
test = test.replace(
    "from __future__ import annotations\n\nfrom dev.benchmarks.validate_panel_stage_b_gpu import (\n",
    "from __future__ import annotations\n\nimport numpy as np\nimport pytest\n\n"
    "from statgpu.panel import PanelOLS, RandomEffects\n\n"
    "from dev.benchmarks.validate_panel_stage_b_gpu import (\n",
    1,
)
test = test.replace(
    "    _dataset,\n    _fit_cases,\n    _model_snapshot,\n",
    "    _dataset,\n    _fit_cases,\n    _hausman_applicable_dataset,\n"
    "    _model_snapshot,\n    _require_applicable_hausman_coverage,\n",
    1,
)
test += '''


def test_physical_runner_has_stable_nonzero_effect_applicable_hausman_fixture():
    X, y, entity, _time, metadata = _hausman_applicable_dataset()
    fe = PanelOLS(entity_effects=True, cov_type="nonrobust").fit(
        X, y, entity_ids=entity
    )
    re = RandomEffects().fit(X, y, entity_ids=entity)
    result = fe.hausman_test(re)
    variance_difference = float(
        np.asarray(fe._panel_cov_param) [0, 0]
        - np.asarray(re._panel_cov_params)[0, 0]
    )

    assert metadata == {
        "seed": 20260810,
        "n_entities": 12,
        "n_times": 4,
        "entity_effect_scale": 0.005,
        "noise_scale": 0.1,
    }
    assert metadata["entity_effect_scale"] > 0.0
    assert X.shape == (48, 1)
    assert result.applicable is True
    assert result.reason is None
    assert result.df == 1.0
    assert np.isfinite(float(result.statistic))
    assert np.isfinite(float(result.pvalue))
    assert variance_difference > 1e-6


def test_physical_runner_requires_recorded_applicable_hausman_per_backend():
    with pytest.raises(AssertionError, match="successful applicable"):
        _require_applicable_hausman_coverage(
            {
                "hausman_balanced": {
                    "status": "success",
                    "applicable": False,
                },
                "hausman_unbalanced": {
                    "status": "success",
                    "applicable": False,
                },
            },
            backend="torch",
        )

    with pytest.raises(AssertionError, match="successful applicable"):
        _require_applicable_hausman_coverage(
            {
                "hausman_missing_values": {
                    "status": "success",
                    "applicable": True,
                }
            },
            backend="cupy",
        )

    applicable = _require_applicable_hausman_coverage(
        {
            "hausman_balanced": {
                "status": "success",
                "applicable": False,
            },
            "hausman_applicable_nonzero_effect": {
                "status": "success",
                "applicable": True,
                "statistic": 1.2,
                "pvalue": 0.27,
                "df": 1.0,
            },
        },
        backend="cupy",
    )
    assert applicable == ["hausman_applicable_nonzero_effect"]
'''
test_path.write_text(test, encoding="utf-8")
'))" + + - name: Install physical-like targeted dependencies run: | - python - <<'PY' - import numpy as np - from statgpu.panel import PanelOLS, RandomEffects + python -m pip install --upgrade pip + python -m pip install numpy==1.24.2 scipy==1.10.1 joblib pytest + python -m pip install -e . --no-deps - best = None - for n_entities in (12, 24, 32, 48): - for n_times in (4, 6, 8, 12): - entity = np.repeat(np.arange(n_entities), n_times) - for effect_scale in (0.005, 0.01, 0.03, 0.08, 0.2, 0.5): - for noise_scale in (0.1, 0.2, 0.5, 1.0): - for seed in range(20260810, 20260870): - rng = np.random.default_rng(seed) - X = rng.normal(size=(entity.size, 1)) - alpha = np.repeat( - rng.normal(scale=effect_scale, size=n_entities), - n_times, - ) - y = 0.8 * X[:, 0] + alpha + rng.normal( - scale=noise_scale, size=entity.size - ) - fe = PanelOLS( - entity_effects=True, - cov_type='nonrobust', - device='cpu', - ).fit(X, y, entity_ids=entity) - re = RandomEffects(device='cpu').fit( - X, y, entity_ids=entity - ) - result = fe.hausman_test(re) - dvar = float( - np.asarray(fe._panel_cov_params)[0, 0] - - np.asarray(re._panel_cov_params)[0, 0] - ) - candidate = ( - dvar, n_entities, n_times, effect_scale, - noise_scale, seed, result.applicable, - result.statistic, result.pvalue, result.df, - result.reason, - ) - if best is None or dvar > best[0]: - best = candidate - if result.applicable: - print('FOUND_NONZERO', candidate) - raise SystemExit(0) - print('BEST_NONZERO', best) - raise SystemExit('no nonzero-effect applicable fitted Hausman fixture found') - PY + - name: Run targeted Stage-B review gates + run: | + python -m pytest -q \ + dev/tests/test_panel_stage_b_physical_runner_contract.py \ + dev/tests/test_panel_stage_b_diagnostics.py \ + dev/tests/test_panel_stage_b_hausman_covariance.py \ + dev/tests/test_panel_stage_b_review_regressions.py + python -m compileall -q dev/benchmarks/validate_panel_stage_b_gpu.py + git diff --check + + - name: Commit focused fix and remove temporary carrier + run: | + rm .github/workflows/pr122-autofix-applicable-hausman.yml + git diff --check + git config user.name 'github-actions[bot]' + git config user.email '41898282+github-actions[bot]@users.noreply.github.com' + git add -A + git commit -m 'test: require applicable Hausman GPU coverage' + git push origin HEAD:agent/panel-p1-stage-b-diagnostics From f05da453fd5c0a020a6824f1e8e53520deee25b7 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 18:38:59 +0800 Subject: [PATCH 134/165] ci: retry PR122 Hausman autofix after test typo --- .../pr122-autofix-applicable-hausman-v2.yml | 75 +++++++++++++++++++ 1 file changed, 75 insertions(+) create mode 100644 .github/workflows/pr122-autofix-applicable-hausman-v2.yml diff --git a/.github/workflows/pr122-autofix-applicable-hausman-v2.yml b/.github/workflows/pr122-autofix-applicable-hausman-v2.yml new file mode 100644 index 000000000..e1d847fde --- /dev/null +++ b/.github/workflows/pr122-autofix-applicable-hausman-v2.yml @@ -0,0 +1,75 @@ +name: PR122 Applicable Hausman Autofix V2 + +on: + push: + branches: + - agent/panel-p1-stage-b-diagnostics + paths: + - .github/workflows/pr122-autofix-applicable-hausman-v2.yml + +permissions: + contents: write + +jobs: + autofix: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + ref: agent/panel-p1-stage-b-diagnostics + fetch-depth: 0 + + - uses: actions/setup-python@v5 + with: + python-version: '3.9' + + - name: Reuse validated patch and correct carrier typo + run: | + python - <<'PY' + import base64 + import re + from pathlib import Path + + carrier = Path('.github/workflows/pr122-autofix-applicable-hausman.yml').read_text(encoding='utf-8') + match = re.search(r"base64\.b64decode\('([^']+)'\)", carrier) + if match is None: + raise RuntimeError('unable to recover validated patch payload') + exec(base64.b64decode(match.group(1)), {}) + + test_path = Path('dev/tests/test_panel_stage_b_physical_runner_contract.py') + text = test_path.read_text(encoding='utf-8') + old = 'np.asarray(fe._panel_cov_param) [0, 0]' + if old not in text: + old = 'np.asarray(fe._panel_cov_param)[0, 0]' + if old not in text: + raise RuntimeError('expected carrier typo not found') + text = text.replace(old, 'np.asarray(fe._panel_cov_params)[0, 0]', 1) + test_path.write_text(text, encoding='utf-8') + PY + + - name: Install physical-like targeted dependencies + run: | + python -m pip install --upgrade pip + python -m pip install numpy==1.24.2 scipy==1.10.1 joblib pytest + python -m pip install -e . --no-deps + + - name: Run targeted Stage-B review gates + run: | + python -m pytest -q \ + dev/tests/test_panel_stage_b_physical_runner_contract.py \ + dev/tests/test_panel_stage_b_diagnostics.py \ + dev/tests/test_panel_stage_b_hausman_covariance.py \ + dev/tests/test_panel_stage_b_review_regressions.py + python -m compileall -q dev/benchmarks/validate_panel_stage_b_gpu.py + git diff --check + + - name: Commit focused fix and remove temporary carriers + run: | + rm .github/workflows/pr122-autofix-applicable-hausman.yml + rm .github/workflows/pr122-autofix-applicable-hausman-v2.yml + git diff --check + git config user.name 'github-actions[bot]' + git config user.email '41898282+github-actions[bot]@users.noreply.github.com' + git add -A + git commit -m 'test: require applicable Hausman GPU coverage' + git push origin HEAD:agent/panel-p1-stage-b-diagnostics From 82d837f2265c61123371b8413041e9cc8e6d51b4 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Sun, 9 Aug 2026 10:39:33 +0000 Subject: [PATCH 135/165] test: require applicable Hausman GPU coverage --- .../pr122-autofix-applicable-hausman-v2.yml | 75 ------- .../pr122-autofix-applicable-hausman.yml | 53 ----- dev/benchmarks/validate_panel_stage_b_gpu.py | 200 +++++++++++++++++- ..._panel_stage_b_physical_runner_contract.py | 83 ++++++++ 4 files changed, 281 insertions(+), 130 deletions(-) delete mode 100644 .github/workflows/pr122-autofix-applicable-hausman-v2.yml delete mode 100644 .github/workflows/pr122-autofix-applicable-hausman.yml diff --git a/.github/workflows/pr122-autofix-applicable-hausman-v2.yml b/.github/workflows/pr122-autofix-applicable-hausman-v2.yml deleted file mode 100644 index e1d847fde..000000000 --- a/.github/workflows/pr122-autofix-applicable-hausman-v2.yml +++ /dev/null @@ -1,75 +0,0 @@ -name: PR122 Applicable Hausman Autofix V2 - -on: - push: - branches: - - agent/panel-p1-stage-b-diagnostics - paths: - - .github/workflows/pr122-autofix-applicable-hausman-v2.yml - -permissions: - contents: write - -jobs: - autofix: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v4 - with: - ref: agent/panel-p1-stage-b-diagnostics - fetch-depth: 0 - - - uses: actions/setup-python@v5 - with: - python-version: '3.9' - - - name: Reuse validated patch and correct carrier typo - run: | - python - <<'PY' - import base64 - import re - from pathlib import Path - - carrier = Path('.github/workflows/pr122-autofix-applicable-hausman.yml').read_text(encoding='utf-8') - match = re.search(r"base64\.b64decode\('([^']+)'\)", carrier) - if match is None: - raise RuntimeError('unable to recover validated patch payload') - exec(base64.b64decode(match.group(1)), {}) - - test_path = Path('dev/tests/test_panel_stage_b_physical_runner_contract.py') - text = test_path.read_text(encoding='utf-8') - old = 'np.asarray(fe._panel_cov_param) [0, 0]' - if old not in text: - old = 'np.asarray(fe._panel_cov_param)[0, 0]' - if old not in text: - raise RuntimeError('expected carrier typo not found') - text = text.replace(old, 'np.asarray(fe._panel_cov_params)[0, 0]', 1) - test_path.write_text(text, encoding='utf-8') - PY - - - name: Install physical-like targeted dependencies - run: | - python -m pip install --upgrade pip - python -m pip install numpy==1.24.2 scipy==1.10.1 joblib pytest - python -m pip install -e . --no-deps - - - name: Run targeted Stage-B review gates - run: | - python -m pytest -q \ - dev/tests/test_panel_stage_b_physical_runner_contract.py \ - dev/tests/test_panel_stage_b_diagnostics.py \ - dev/tests/test_panel_stage_b_hausman_covariance.py \ - dev/tests/test_panel_stage_b_review_regressions.py - python -m compileall -q dev/benchmarks/validate_panel_stage_b_gpu.py - git diff --check - - - name: Commit focused fix and remove temporary carriers - run: | - rm .github/workflows/pr122-autofix-applicable-hausman.yml - rm .github/workflows/pr122-autofix-applicable-hausman-v2.yml - git diff --check - git config user.name 'github-actions[bot]' - git config user.email '41898282+github-actions[bot]@users.noreply.github.com' - git add -A - git commit -m 'test: require applicable Hausman GPU coverage' - git push origin HEAD:agent/panel-p1-stage-b-diagnostics diff --git a/.github/workflows/pr122-autofix-applicable-hausman.yml b/.github/workflows/pr122-autofix-applicable-hausman.yml deleted file mode 100644 index 177abe5f4..000000000 --- a/.github/workflows/pr122-autofix-applicable-hausman.yml +++ /dev/null @@ -1,53 +0,0 @@ -name: PR122 Applicable Hausman Autofix - -on: - push: - branches: - - agent/panel-p1-stage-b-diagnostics - paths: - - .github/workflows/pr122-autofix-applicable-hausman.yml - -permissions: - contents: write - -jobs: - autofix: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v4 - with: - ref: agent/panel-p1-stage-b-diagnostics - fetch-depth: 0 - - - uses: actions/setup-python@v5 - with: - python-version: '3.9' - - - name: Apply focused Hausman physical gate patch - run: python -c "import base64; exec(base64.b64decode('
from pathlib import Path

runner_path = Path("dev/benchmarks/validate_panel_stage_b_gpu.py")
runner = runner_path.read_text(encoding="utf-8")

anchor = "    return cases, diagnostics\n\n\ndef _scalar_diff(actual, expected, *, rtol, atol, label):\n"
replacement = '''    return cases, diagnostics


def _hausman_applicable_dataset():
    \'\'\'Deterministic nonzero-effect panel with an applicable fitted Hausman test.\'\'\'
    seed = 20260810
    n_entities, n_times = 12, 4
    effect_scale, noise_scale = 0.005, 0.1
    rng = np.random.default_rng(seed)
    entity = np.repeat(np.arange(n_entities), n_times)
    time = np.tile(np.arange(n_times), n_entities)
    X = rng.normal(size=(entity.size, 1))
    entity_effect = np.repeat(
        rng.normal(scale=effect_scale, size=n_entities),
        n_times,
    )
    y = (
        0.8 * X[:, 0]
        + entity_effect
        + rng.normal(scale=noise_scale, size=entity.size)
    )
    metadata = {
        "seed": seed,
        "n_entities": n_entities,
        "n_times": n_times,
        "entity_effect_scale": effect_scale,
        "noise_scale": noise_scale,
    }
    return X.astype(np.float64), y.astype(np.float64), entity, time, metadata


def _require_applicable_hausman_coverage(diagnostics, *, backend):
    \'\'\'Require a successful applicable Hausman statistic/p-value per backend.\'\'\'
    applicable = []
    for name, payload in diagnostics.items():
        if payload.get("status") != "success" or payload.get("applicable") is not True:
            continue
        statistic = payload.get("statistic")
        pvalue = payload.get("pvalue")
        df = payload.get("df")
        if statistic is None or pvalue is None or df is None:
            continue
        if not (
            np.isfinite(float(statistic))
            and np.isfinite(float(pvalue))
            and np.isfinite(float(df))
            and float(df) > 0.0
        ):
            continue
        applicable.append(name)
    if not applicable:
        raise AssertionError(
            f"{backend}: physical Hausman gate requires at least one successful "
            "applicable statistic/pvalue/df case"
        )
    return sorted(applicable)


def _scalar_diff(actual, expected, *, rtol, atol, label):
'''
if anchor not in runner:
    raise SystemExit("runner helper anchor not found")
runner = runner.replace(anchor, replacement, 1)

anchor = "        reference_diagnostics.update(diagnostics)\n\n    results = {}\n"
replacement = '''        reference_diagnostics.update(diagnostics)

    (
        hausman_X,
        hausman_y,
        hausman_entity,
        hausman_time,
        hausman_fixture_metadata,
    ) = _hausman_applicable_dataset()
    hausman_fe_reference = PanelOLS(
        entity_effects=True,
        cov_type="nonrobust",
        device="cpu",
    ).fit(hausman_X, hausman_y, entity_ids=hausman_entity)
    hausman_re_reference = RandomEffects(device="cpu").fit(
        hausman_X, hausman_y, entity_ids=hausman_entity
    )
    hausman_reference = _test_result(
        hausman_fe_reference.hausman_test(hausman_re_reference)
    )
    hausman_variance_difference = float(
        np.asarray(hausman_fe_reference._panel_cov_params, dtype=np.float64)[0, 0]
        - np.asarray(hausman_re_reference._panel_cov_params, dtype=np.float64)[0, 0]
    )
    if not hausman_reference["applicable"]:
        raise AssertionError(
            "hosted reference Hausman fixture must remain applicable: "
            f"{hausman_reference['reason']}"
        )
    if hausman_variance_difference <= 1e-6:
        raise AssertionError(
            "hosted reference Hausman covariance-difference margin is too small: "
            f"{hausman_variance_difference}"
        )
    reference_diagnostics["hausman_applicable_nonzero_effect"] = hausman_reference

    results = {}
'''
if anchor not in runner:
    raise SystemExit("reference fixture anchor not found")
runner = runner.replace(anchor, replacement, 1)

anchor = "        results[backend] = backend_payload\n\n    payload = {\n"
replacement = '''        Xhb, yhb, ehb, _ = _to_backend_arrays(
            hausman_X,
            hausman_y,
            hausman_entity,
            hausman_time,
            backend,
        )
        device = _device_arg(backend)
        hausman_fe = PanelOLS(
            entity_effects=True,
            cov_type="nonrobust",
            device=device,
        ).fit(Xhb, yhb, entity_ids=ehb)
        hausman_re = RandomEffects(device=device).fit(Xhb, yhb, entity_ids=ehb)
        for model_name, model in (
            ("hausman_applicable_fe", hausman_fe),
            ("hausman_applicable_re", hausman_re),
        ):
            actual_backend = _backend_name(model)
            if actual_backend != backend:
                raise AssertionError(
                    f"{model_name}: requested {backend}, executed {actual_backend}"
                )

        hausman_result = _test_result(hausman_fe.hausman_test(hausman_re))
        if not hausman_result["applicable"]:
            raise AssertionError(
                f"hausman_applicable_nonzero_effect unexpectedly inapplicable on "
                f"{backend}: {hausman_result['reason']}"
            )
        hausman_differences = _compare_test_result(
            reference_diagnostics["hausman_applicable_nonzero_effect"],
            hausman_result,
            rtol=args.rtol,
            atol=args.atol,
            label="hausman_applicable_nonzero_effect",
        )
        fe_coef = _array(hausman_fe.coef_).ravel()
        re_coef = _array(hausman_re.coef_).ravel()
        fe_cov = _array(hausman_fe._panel_cov_params)
        re_cov = _array(hausman_re._panel_cov_params)
        np.testing.assert_allclose(
            fe_coef,
            _array(hausman_fe_reference.coef_).ravel(),
            rtol=args.rtol,
            atol=args.atol,
            err_msg="hausman_applicable_nonzero_effect.fe_coef",
        )
        np.testing.assert_allclose(
            re_coef,
            _array(hausman_re_reference.coef_).ravel(),
            rtol=args.rtol,
            atol=args.atol,
            err_msg="hausman_applicable_nonzero_effect.re_coef",
        )
        np.testing.assert_allclose(
            fe_cov,
            _array(hausman_fe_reference._panel_cov_params),
            rtol=args.rtol,
            atol=args.atol,
            err_msg="hausman_applicable_nonzero_effect.fe_covariance",
        )
        np.testing.assert_allclose(
            re_cov,
            _array(hausman_re_reference._panel_cov_params),
            rtol=args.rtol,
            atol=args.atol,
            err_msg="hausman_applicable_nonzero_effect.re_covariance",
        )
        backend_payload["diagnostics"]["hausman_applicable_nonzero_effect"] = {
            "status": "success",
            "max_abs_differences": hausman_differences,
            "fit_max_abs_differences": {
                "fe_coef": _max_abs_difference(
                    fe_coef, _array(hausman_fe_reference.coef_).ravel()
                ),
                "re_coef": _max_abs_difference(
                    re_coef, _array(hausman_re_reference.coef_).ravel()
                ),
                "fe_covariance": _max_abs_difference(
                    fe_cov, _array(hausman_fe_reference._panel_cov_params)
                ),
                "re_covariance": _max_abs_difference(
                    re_cov, _array(hausman_re_reference._panel_cov_params)
                ),
            },
            "applicable": True,
            "reason": hausman_result["reason"],
            "statistic": hausman_result["statistic"],
            "pvalue": hausman_result["pvalue"],
            "df": hausman_result["df"],
            "reference_statistic": hausman_reference["statistic"],
            "reference_pvalue": hausman_reference["pvalue"],
            "reference_df": hausman_reference["df"],
            "reference_variance_difference": hausman_variance_difference,
            "fixture": dict(hausman_fixture_metadata),
        }
        _require_applicable_hausman_coverage(
            backend_payload["diagnostics"], backend=backend
        )
        results[backend] = backend_payload

    payload = {
'''
if anchor not in runner:
    raise SystemExit("backend coverage anchor not found")
runner = runner.replace(anchor, replacement, 1)

anchor = '''        "datasets": {
            name: {"nobs": int(len(values[1]))}
            for name, values in datasets.items()
        },
'''
replacement = '''        "datasets": {
            **{
                name: {"nobs": int(len(values[1]))}
                for name, values in datasets.items()
            },
            "hausman_applicable_nonzero_effect": {
                "nobs": int(len(hausman_y)),
                **dict(hausman_fixture_metadata),
                "reference_variance_difference": hausman_variance_difference,
            },
        },
'''
if anchor not in runner:
    raise SystemExit("dataset metadata anchor not found")
runner = runner.replace(anchor, replacement, 1)
runner_path.write_text(runner, encoding="utf-8")

test_path = Path("dev/tests/test_panel_stage_b_physical_runner_contract.py")
test = test_path.read_text(encoding="utf-8")
test = test.replace(
    "from __future__ import annotations\n\nfrom dev.benchmarks.validate_panel_stage_b_gpu import (\n",
    "from __future__ import annotations\n\nimport numpy as np\nimport pytest\n\n"
    "from statgpu.panel import PanelOLS, RandomEffects\n\n"
    "from dev.benchmarks.validate_panel_stage_b_gpu import (\n",
    1,
)
test = test.replace(
    "    _dataset,\n    _fit_cases,\n    _model_snapshot,\n",
    "    _dataset,\n    _fit_cases,\n    _hausman_applicable_dataset,\n"
    "    _model_snapshot,\n    _require_applicable_hausman_coverage,\n",
    1,
)
test += '''


def test_physical_runner_has_stable_nonzero_effect_applicable_hausman_fixture():
    X, y, entity, _time, metadata = _hausman_applicable_dataset()
    fe = PanelOLS(entity_effects=True, cov_type="nonrobust").fit(
        X, y, entity_ids=entity
    )
    re = RandomEffects().fit(X, y, entity_ids=entity)
    result = fe.hausman_test(re)
    variance_difference = float(
        np.asarray(fe._panel_cov_param) [0, 0]
        - np.asarray(re._panel_cov_params)[0, 0]
    )

    assert metadata == {
        "seed": 20260810,
        "n_entities": 12,
        "n_times": 4,
        "entity_effect_scale": 0.005,
        "noise_scale": 0.1,
    }
    assert metadata["entity_effect_scale"] > 0.0
    assert X.shape == (48, 1)
    assert result.applicable is True
    assert result.reason is None
    assert result.df == 1.0
    assert np.isfinite(float(result.statistic))
    assert np.isfinite(float(result.pvalue))
    assert variance_difference > 1e-6


def test_physical_runner_requires_recorded_applicable_hausman_per_backend():
    with pytest.raises(AssertionError, match="successful applicable"):
        _require_applicable_hausman_coverage(
            {
                "hausman_balanced": {
                    "status": "success",
                    "applicable": False,
                },
                "hausman_unbalanced": {
                    "status": "success",
                    "applicable": False,
                },
            },
            backend="torch",
        )

    with pytest.raises(AssertionError, match="successful applicable"):
        _require_applicable_hausman_coverage(
            {
                "hausman_missing_values": {
                    "status": "success",
                    "applicable": True,
                }
            },
            backend="cupy",
        )

    applicable = _require_applicable_hausman_coverage(
        {
            "hausman_balanced": {
                "status": "success",
                "applicable": False,
            },
            "hausman_applicable_nonzero_effect": {
                "status": "success",
                "applicable": True,
                "statistic": 1.2,
                "pvalue": 0.27,
                "df": 1.0,
            },
        },
        backend="cupy",
    )
    assert applicable == ["hausman_applicable_nonzero_effect"]
'''
test_path.write_text(test, encoding="utf-8")
'))" - - - name: Install physical-like targeted dependencies - run: | - python -m pip install --upgrade pip - python -m pip install numpy==1.24.2 scipy==1.10.1 joblib pytest - python -m pip install -e . --no-deps - - - name: Run targeted Stage-B review gates - run: | - python -m pytest -q \ - dev/tests/test_panel_stage_b_physical_runner_contract.py \ - dev/tests/test_panel_stage_b_diagnostics.py \ - dev/tests/test_panel_stage_b_hausman_covariance.py \ - dev/tests/test_panel_stage_b_review_regressions.py - python -m compileall -q dev/benchmarks/validate_panel_stage_b_gpu.py - git diff --check - - - name: Commit focused fix and remove temporary carrier - run: | - rm .github/workflows/pr122-autofix-applicable-hausman.yml - git diff --check - git config user.name 'github-actions[bot]' - git config user.email '41898282+github-actions[bot]@users.noreply.github.com' - git add -A - git commit -m 'test: require applicable Hausman GPU coverage' - git push origin HEAD:agent/panel-p1-stage-b-diagnostics diff --git a/dev/benchmarks/validate_panel_stage_b_gpu.py b/dev/benchmarks/validate_panel_stage_b_gpu.py index 1bd9f71d5..954776bc7 100644 --- a/dev/benchmarks/validate_panel_stage_b_gpu.py +++ b/dev/benchmarks/validate_panel_stage_b_gpu.py @@ -251,6 +251,61 @@ def _fit_cases(X, y, entity, time, backend, *, unbalanced): return cases, diagnostics +def _hausman_applicable_dataset(): + '''Deterministic nonzero-effect panel with an applicable fitted Hausman test.''' + seed = 20260810 + n_entities, n_times = 12, 4 + effect_scale, noise_scale = 0.005, 0.1 + rng = np.random.default_rng(seed) + entity = np.repeat(np.arange(n_entities), n_times) + time = np.tile(np.arange(n_times), n_entities) + X = rng.normal(size=(entity.size, 1)) + entity_effect = np.repeat( + rng.normal(scale=effect_scale, size=n_entities), + n_times, + ) + y = ( + 0.8 * X[:, 0] + + entity_effect + + rng.normal(scale=noise_scale, size=entity.size) + ) + metadata = { + "seed": seed, + "n_entities": n_entities, + "n_times": n_times, + "entity_effect_scale": effect_scale, + "noise_scale": noise_scale, + } + return X.astype(np.float64), y.astype(np.float64), entity, time, metadata + + +def _require_applicable_hausman_coverage(diagnostics, *, backend): + '''Require a successful applicable Hausman statistic/p-value per backend.''' + applicable = [] + for name, payload in diagnostics.items(): + if payload.get("status") != "success" or payload.get("applicable") is not True: + continue + statistic = payload.get("statistic") + pvalue = payload.get("pvalue") + df = payload.get("df") + if statistic is None or pvalue is None or df is None: + continue + if not ( + np.isfinite(float(statistic)) + and np.isfinite(float(pvalue)) + and np.isfinite(float(df)) + and float(df) > 0.0 + ): + continue + applicable.append(name) + if not applicable: + raise AssertionError( + f"{backend}: physical Hausman gate requires at least one successful " + "applicable statistic/pvalue/df case" + ) + return sorted(applicable) + + def _scalar_diff(actual, expected, *, rtol, atol, label): if expected is None: if actual is not None: @@ -439,6 +494,40 @@ def main(): ) reference_diagnostics.update(diagnostics) + ( + hausman_X, + hausman_y, + hausman_entity, + hausman_time, + hausman_fixture_metadata, + ) = _hausman_applicable_dataset() + hausman_fe_reference = PanelOLS( + entity_effects=True, + cov_type="nonrobust", + device="cpu", + ).fit(hausman_X, hausman_y, entity_ids=hausman_entity) + hausman_re_reference = RandomEffects(device="cpu").fit( + hausman_X, hausman_y, entity_ids=hausman_entity + ) + hausman_reference = _test_result( + hausman_fe_reference.hausman_test(hausman_re_reference) + ) + hausman_variance_difference = float( + np.asarray(hausman_fe_reference._panel_cov_params, dtype=np.float64)[0, 0] + - np.asarray(hausman_re_reference._panel_cov_params, dtype=np.float64)[0, 0] + ) + if not hausman_reference["applicable"]: + raise AssertionError( + "hosted reference Hausman fixture must remain applicable: " + f"{hausman_reference['reason']}" + ) + if hausman_variance_difference <= 1e-6: + raise AssertionError( + "hosted reference Hausman covariance-difference margin is too small: " + f"{hausman_variance_difference}" + ) + reference_diagnostics["hausman_applicable_nonzero_effect"] = hausman_reference + results = {} for backend in backends: backend_payload = {"models": {}, "diagnostics": {}} @@ -479,6 +568,106 @@ def main(): "applicable": result["applicable"], "reason": result["reason"], } + Xhb, yhb, ehb, _ = _to_backend_arrays( + hausman_X, + hausman_y, + hausman_entity, + hausman_time, + backend, + ) + device = _device_arg(backend) + hausman_fe = PanelOLS( + entity_effects=True, + cov_type="nonrobust", + device=device, + ).fit(Xhb, yhb, entity_ids=ehb) + hausman_re = RandomEffects(device=device).fit(Xhb, yhb, entity_ids=ehb) + for model_name, model in ( + ("hausman_applicable_fe", hausman_fe), + ("hausman_applicable_re", hausman_re), + ): + actual_backend = _backend_name(model) + if actual_backend != backend: + raise AssertionError( + f"{model_name}: requested {backend}, executed {actual_backend}" + ) + + hausman_result = _test_result(hausman_fe.hausman_test(hausman_re)) + if not hausman_result["applicable"]: + raise AssertionError( + f"hausman_applicable_nonzero_effect unexpectedly inapplicable on " + f"{backend}: {hausman_result['reason']}" + ) + hausman_differences = _compare_test_result( + reference_diagnostics["hausman_applicable_nonzero_effect"], + hausman_result, + rtol=args.rtol, + atol=args.atol, + label="hausman_applicable_nonzero_effect", + ) + fe_coef = _array(hausman_fe.coef_).ravel() + re_coef = _array(hausman_re.coef_).ravel() + fe_cov = _array(hausman_fe._panel_cov_params) + re_cov = _array(hausman_re._panel_cov_params) + np.testing.assert_allclose( + fe_coef, + _array(hausman_fe_reference.coef_).ravel(), + rtol=args.rtol, + atol=args.atol, + err_msg="hausman_applicable_nonzero_effect.fe_coef", + ) + np.testing.assert_allclose( + re_coef, + _array(hausman_re_reference.coef_).ravel(), + rtol=args.rtol, + atol=args.atol, + err_msg="hausman_applicable_nonzero_effect.re_coef", + ) + np.testing.assert_allclose( + fe_cov, + _array(hausman_fe_reference._panel_cov_params), + rtol=args.rtol, + atol=args.atol, + err_msg="hausman_applicable_nonzero_effect.fe_covariance", + ) + np.testing.assert_allclose( + re_cov, + _array(hausman_re_reference._panel_cov_params), + rtol=args.rtol, + atol=args.atol, + err_msg="hausman_applicable_nonzero_effect.re_covariance", + ) + backend_payload["diagnostics"]["hausman_applicable_nonzero_effect"] = { + "status": "success", + "max_abs_differences": hausman_differences, + "fit_max_abs_differences": { + "fe_coef": _max_abs_difference( + fe_coef, _array(hausman_fe_reference.coef_).ravel() + ), + "re_coef": _max_abs_difference( + re_coef, _array(hausman_re_reference.coef_).ravel() + ), + "fe_covariance": _max_abs_difference( + fe_cov, _array(hausman_fe_reference._panel_cov_params) + ), + "re_covariance": _max_abs_difference( + re_cov, _array(hausman_re_reference._panel_cov_params) + ), + }, + "applicable": True, + "reason": hausman_result["reason"], + "statistic": hausman_result["statistic"], + "pvalue": hausman_result["pvalue"], + "df": hausman_result["df"], + "reference_statistic": hausman_reference["statistic"], + "reference_pvalue": hausman_reference["pvalue"], + "reference_df": hausman_reference["df"], + "reference_variance_difference": hausman_variance_difference, + "fixture": dict(hausman_fixture_metadata), + } + _require_applicable_hausman_coverage( + backend_payload["diagnostics"], backend=backend + ) results[backend] = backend_payload payload = { @@ -490,8 +679,15 @@ def main(): "environment": _environment(backends), "tolerances": {"rtol": args.rtol, "atol": args.atol}, "datasets": { - name: {"nobs": int(len(values[1]))} - for name, values in datasets.items() + **{ + name: {"nobs": int(len(values[1]))} + for name, values in datasets.items() + }, + "hausman_applicable_nonzero_effect": { + "nobs": int(len(hausman_y)), + **dict(hausman_fixture_metadata), + "reference_variance_difference": hausman_variance_difference, + }, }, "backends": results, } diff --git a/dev/tests/test_panel_stage_b_physical_runner_contract.py b/dev/tests/test_panel_stage_b_physical_runner_contract.py index 8ae87c7e0..178b0dde5 100644 --- a/dev/tests/test_panel_stage_b_physical_runner_contract.py +++ b/dev/tests/test_panel_stage_b_physical_runner_contract.py @@ -2,10 +2,17 @@ from __future__ import annotations +import numpy as np +import pytest + +from statgpu.panel import PanelOLS, RandomEffects + from dev.benchmarks.validate_panel_stage_b_gpu import ( _dataset, _fit_cases, + _hausman_applicable_dataset, _model_snapshot, + _require_applicable_hausman_coverage, ) @@ -63,3 +70,79 @@ def test_physical_runner_total_model_case_contract_is_seventeen(): assert "random_effects_explicit_constant_unbalanced" in case_ids assert "hausman_explicit_re_constant_balanced" in diagnostic_ids assert "hausman_explicit_re_constant_unbalanced" in diagnostic_ids + + + +def test_physical_runner_has_stable_nonzero_effect_applicable_hausman_fixture(): + X, y, entity, _time, metadata = _hausman_applicable_dataset() + fe = PanelOLS(entity_effects=True, cov_type="nonrobust").fit( + X, y, entity_ids=entity + ) + re = RandomEffects().fit(X, y, entity_ids=entity) + result = fe.hausman_test(re) + variance_difference = float( + np.asarray(fe._panel_cov_params)[0, 0] + - np.asarray(re._panel_cov_params)[0, 0] + ) + + assert metadata == { + "seed": 20260810, + "n_entities": 12, + "n_times": 4, + "entity_effect_scale": 0.005, + "noise_scale": 0.1, + } + assert metadata["entity_effect_scale"] > 0.0 + assert X.shape == (48, 1) + assert result.applicable is True + assert result.reason is None + assert result.df == 1.0 + assert np.isfinite(float(result.statistic)) + assert np.isfinite(float(result.pvalue)) + assert variance_difference > 1e-6 + + +def test_physical_runner_requires_recorded_applicable_hausman_per_backend(): + with pytest.raises(AssertionError, match="successful applicable"): + _require_applicable_hausman_coverage( + { + "hausman_balanced": { + "status": "success", + "applicable": False, + }, + "hausman_unbalanced": { + "status": "success", + "applicable": False, + }, + }, + backend="torch", + ) + + with pytest.raises(AssertionError, match="successful applicable"): + _require_applicable_hausman_coverage( + { + "hausman_missing_values": { + "status": "success", + "applicable": True, + } + }, + backend="cupy", + ) + + applicable = _require_applicable_hausman_coverage( + { + "hausman_balanced": { + "status": "success", + "applicable": False, + }, + "hausman_applicable_nonzero_effect": { + "status": "success", + "applicable": True, + "statistic": 1.2, + "pvalue": 0.27, + "df": 1.0, + }, + }, + backend="cupy", + ) + assert applicable == ["hausman_applicable_nonzero_effect"] From 0b9c9b20d3b63ad7275d1879d633a067a8cf7e67 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 18:41:14 +0800 Subject: [PATCH 136/165] docs: reopen PR122 physical gate for applicable Hausman coverage --- dev/reviews/pr122_physical_gpu_validation.md | 147 ++++++++++++------- 1 file changed, 95 insertions(+), 52 deletions(-) diff --git a/dev/reviews/pr122_physical_gpu_validation.md b/dev/reviews/pr122_physical_gpu_validation.md index 2f48355b4..d5bac18e3 100644 --- a/dev/reviews/pr122_physical_gpu_validation.md +++ b/dev/reviews/pr122_physical_gpu_validation.md @@ -1,87 +1,130 @@ # PR #122 Panel Stage B physical GPU validation -## Final acceptance status +## Current acceptance status -Panel Tier-1 Stage B has current physical GPU acceptance for exact numerical implementation head `a57efcea29b0e87ecb89865c5a6902d5773812c6`. +**PARTIAL_REMOTE_PENDING**. -Both maintained P100 gates were executed from that exact implementation with a clean working tree and completed successfully on CuPy and Torch CUDA: +The previously accepted Panel Tier-1 Stage B numerical implementation `a57efcea29b0e87ecb89865c5a6902d5773812c6` remains useful historical physical evidence, but it is no longer sufficient for final PR #122 acceptance because `dev/benchmarks/validate_panel_stage_b_gpu.py` changed after that measurement. -1. `dev/benchmarks/validate_panel_stage_b_gpu.py` -2. `dev/benchmarks/validate_panel_stage_b_disconnected_fe_gpu.py` +A Ready-for-review Codex pass identified a physical-coverage gap: all four Hausman diagnostics per CUDA backend in the `a57efcea...` artifact are structured `applicable = false` results because the fitted covariance difference is not positive semidefinite. Those results correctly validate applicability/reason parity against NumPy, but they do not execute an applicable Hausman statistic, p-value, and degrees-of-freedom path on either physical GPU backend. -The raw outputs were committed unchanged in repository commit `72b3279d2028e8ec2af30e138e123aceb611ae8c`. The compare from `a57efcea...` to `72b3279d...` contains only those two JSON evidence files; no numerical implementation or validation-runner code changed. +The review/fix loop therefore reopened the physical gate and returned PR #122 to Draft. -## Raw evidence +## Current runner fix -Full Stage-B matrix: +The current physical runner now contains a dedicated deterministic fitted FE/RE Hausman fixture with: + +- seed `20260810`; +- 12 entities and 4 observations per entity; +- one slope; +- nonzero entity-effect scale `0.005`; +- noise scale `0.1`; +- 48 observations total. + +On the hosted NumPy reference under the physical-like Python 3.9 / NumPy 1.24.2 / SciPy 1.10.1 stack, this fixture is stably applicable with: + +- Hausman df `1`; +- finite statistic and p-value; +- a positive FE-minus-RE diagnostic covariance margin greater than `1e-6`. + +The runner now requires each requested physical backend to provide at least one diagnostic that simultaneously has: + +- `status = "success"`; +- `applicable = true`; +- finite `statistic`; +- finite `pvalue`; +- finite positive `df`. + +For the dedicated applicable fixture the runner also checks requested/executed backend identity and compares FE/RE coefficients, FE/RE diagnostic covariance, Hausman statistic, p-value, and df against the NumPy reference. The original four structured-inapplicable Hausman parameterizations remain in the matrix, so the eventual physical run must cover both applicability branches rather than replacing one with the other. + +Hosted regression coverage also locks the nonzero-effect fixture and verifies that the aggregate physical gate fails closed when every Hausman result is inapplicable or when an `applicable=true` payload omits statistic/p-value/df. + +The targeted review gate passed under Python 3.9 with NumPy 1.24.2 and SciPy 1.10.1 before the focused runner/test fix was committed. + +## Historical raw evidence + +The last accepted full Stage-B physical artifact is retained unchanged: - path: `results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json` - Git blob: `254b64776bff4e3b2b642bb4a2ae1eea25f4751c` - schema version: 2 -- top-level `git_sha`: `a57efcea29b0e87ecb89865c5a6902d5773812c6` -- `working_tree_clean = true` -- `status = success` -- CuPy: all 17 estimator cases and all four Hausman diagnostics succeeded with the requested CuPy backend -- Torch: all 17 estimator cases and all four Hausman diagnostics succeeded with the requested Torch backend -- no timing or speedup measurement was collected +- measured implementation SHA: `a57efcea29b0e87ecb89865c5a6902d5773812c6` +- clean working tree: true +- overall status: success +- CuPy: 17/17 estimator cases, requested backend `cupy`, no fallback +- Torch: 17/17 estimator cases, requested backend `torch`, no fallback +- four Hausman diagnostics per backend, all matching NumPy as structured inapplicable results +- no timing or speedup measurement collected. -Focused disconnected two-way FE gate: +The focused disconnected two-way FE artifact is also retained unchanged: - path: `results/pr122_p100/panel_stage_b_disconnected_fe_gpu_validation_a57efcea.json` - Git blob: `3bda0b2040479ba8201e2722eb990ba086c3f3b9` -- schema version: 1 -- top-level `git_sha`: `a57efcea29b0e87ecb89865c5a6902d5773812c6` -- `working_tree_clean = true` -- `status = success` -- fixture: two disconnected 2x2 incidence blocks plus one singleton +- measured implementation SHA: `a57efcea29b0e87ecb89865c5a6902d5773812c6` +- clean working tree: true - `nobs = 9` -- legacy residual df = 0 -- component-aware/public residual df = 1 -- effect rank = 7 +- legacy residual df `0` +- component-aware/public residual df `1` +- effect rank `7` - `rank_x = 1` -- incidence components = 3 -- CuPy and Torch both executed on the requested backend and matched NumPy within the validator tolerances +- incidence components `3` +- CuPy and Torch requested/executed backend provenance verified +- corrected df=1 confidence intervals agree with NumPy to machine precision. + +These artifacts continue to establish the previously reviewed estimator, inference, disconnected-FE, and structured-inapplicability behavior. They do **not** establish the newly required applicable-Hausman physical branch. + +## Historical environment -The NumPy reference confidence interval for the one-slope fixture is approximately `[-4.853102368087349, 7.853102368087349]`. CuPy and Torch both return approximately `[-4.853102368087348, 7.853102368087348]`; the recorded maximum absolute CI difference is `8.881784197001252e-16` for each GPU backend. +The `a57efcea...` artifacts report: -This focused result closes the physical regression that previously produced a Torch interval of roughly `[-49998.5, 50001.5]` at residual df 1. The repaired panel inference uses the exact identity `Student-t(df=1) == standard Cauchy`; the successful P100 rerun confirms the corrected boundary on physical Torch CUDA as well as CuPy. +- Tesla P100-SXM2-16GB; +- Python 3.9.16; +- statgpu 0.2.4; +- NumPy 1.24.2; +- SciPy 1.10.1; +- PyTorch 2.0.0. -## Environment +The raw artifact records the CuPy package metadata field as `null`, but physical CuPy execution is independently established by the per-case `executed_backend = "cupy"` checks. -Both artifacts report: +## Existing canonical frontend evidence -- GPU: Tesla P100-SXM2-16GB -- Python: 3.9.16 -- statgpu: 0.2.4 -- NumPy: 1.24.2 -- SciPy: 1.10.1 -- PyTorch: 2.0.0 +The currently committed canonical source remains the historical `a57efcea...` measurement: -The runner could not resolve the installed CuPy distribution version through `importlib.metadata`, so the artifact records that package field as `null`. Physical CuPy execution is instead established by the per-backend `executed_backend = "cupy"` provenance checks. +- `results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809.json` +- SHA-256 `a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9` +- source id `panel-stage-b-pr122-20260809-a6e47b9dec9c` +- 42 validation-only rows. -## Canonical frontend evidence +It remains an immutable description of that historical physical run, but it must not be treated as final acceptance for the current runner. After the new exact-clean-head P100 run succeeds, a new canonical source must replace it and the frontend generated assets/contracts must be regenerated. With the new applicable Hausman diagnostic, the expected Stage-B validation row count is 44: 17 estimator cases x 2 backends plus 5 Hausman diagnostics x 2 backends. -Current canonical validation source: +## Required remote closure -- path: `results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809.json` -- canonical SHA-256: `a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9` -- source id: `panel-stage-b-pr122-20260809-a6e47b9dec9c` -- measurement implementation SHA: `a57efcea29b0e87ecb89865c5a6902d5773812c6` -- parser: `panel_stage_b_physical_validation` v1.0 -- validation-only evidence; no timing or speedup is inferred +Final physical acceptance now requires a fresh exact-clean-head P100 execution of `dev/benchmarks/validate_panel_stage_b_gpu.py` on the final runner head, with both CuPy and Torch requested. -The source registers the full 17-case matrix and four Hausman parameterizations per backend, producing 42 validation rows. It also records the focused disconnected-FE gate as supporting provenance rather than inventing timing rows for it. +The new artifact must demonstrate, for each backend: -The earlier canonical source measured at `faa95ce7fb5cb204088957fbda5544c20a06fbfc` is historical evidence for that older implementation and is no longer the current dashboard source. Its immutable raw artifact remains preserved in `results/pr122_p100/`. +1. requested backend equals executed backend with no silent fallback; +2. all 17 estimator cases remain successful against NumPy; +3. the four existing Hausman parameterizations retain their expected structured applicability behavior; +4. `hausman_applicable_nonzero_effect` is `applicable = true`; +5. its Hausman statistic, p-value, and df agree with NumPy within the runner tolerances; +6. its FE/RE coefficients and diagnostic covariance agree with NumPy within the runner tolerances; +7. the top-level run reports a clean working tree and exact expected SHA. -## Applicability after evidence-only commits +After that run is accepted, the lifecycle must: -The physical acceptance is anchored to the exact numerical implementation `a57efcea...`. Subsequent commits may add or promote raw evidence, canonical metadata, frontend contract tests, generated benchmark assets, and review documentation without invalidating the numerical measurement. Physical applicability is preserved provided a repository compare confirms that no numerical production implementation relevant to the measurement and neither physical validation runner changed after `a57efcea...`. +- commit the immutable raw result; +- promote a new canonical Stage-B source; +- update source/coverage contracts for five Hausman diagnostics per backend and 44 validation rows; +- regenerate the six tracked frontend/docs JSON assets; +- rerun exact-final-head hosted CI; +- resolve the applicable-Hausman review thread with the new evidence; +- perform another fresh review under `.claude/skills/code-review.md` before returning the PR to Ready. -Frontend/evidence tests may change to assert the promoted source identity or provenance; those tests do not alter the physically measured numerical implementation. If numerical production code or either physical validation runner changes later, a new exact-head physical validation is required before PR #122 can again be considered physically accepted. +## Hard-exit conclusion -## Acceptance conclusion +Local fix status: the current review finding is fixed in runner/test code and targeted local/hosted checks pass. -**PHYSICAL_GPU_ACCEPTED** for Panel Tier-1 Stage B numerical implementation `a57efcea29b0e87ecb89865c5a6902d5773812c6`. +Remote status: a fresh P100 CuPy/Torch artifact is required because the physical validation runner changed. -The remaining PR lifecycle work is evidence/frontend staleness synchronization, hosted final-head validation, and the normal review-thread/fresh-review process. No additional P100 rerun is required unless numerical production or physical validation-runner code changes. +**Hard exit: PARTIAL_REMOTE_PENDING.** From e80e8ed361335fd2c925f4cd4e24a919a4379c7a Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 18:42:57 +0800 Subject: [PATCH 137/165] ci: stage PR122 Hausman frontend parser fix --- .../pr122-autofix-hausman-parser.yml | 231 ++++++++++++++++++ 1 file changed, 231 insertions(+) create mode 100644 .github/workflows/pr122-autofix-hausman-parser.yml diff --git a/.github/workflows/pr122-autofix-hausman-parser.yml b/.github/workflows/pr122-autofix-hausman-parser.yml new file mode 100644 index 000000000..c1a63902d --- /dev/null +++ b/.github/workflows/pr122-autofix-hausman-parser.yml @@ -0,0 +1,231 @@ +name: PR122 Hausman Parser Autofix + +on: + push: + branches: + - agent/panel-p1-stage-b-diagnostics + paths: + - .github/workflows/pr122-autofix-hausman-parser.yml + +permissions: + contents: write + +jobs: + autofix: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + ref: agent/panel-p1-stage-b-diagnostics + fetch-depth: 0 + + - uses: actions/setup-python@v5 + with: + python-version: '3.11' + + - name: Patch parser and regression contract + run: | + python - <<'PY' + from pathlib import Path + + parser_path = Path('dev/benchmarks/frontend_data/parsers/panel_stage_b.py') + text = parser_path.read_text(encoding='utf-8') + old = ''' for diagnostic_id, diagnostic in backend_result.get("diagnostics", {}).items(): + balance = "unbalanced" if diagnostic_id.endswith("unbalanced") else "balanced" + explicit_re_constant = diagnostic_id.startswith( + "hausman_explicit_re_constant_" + ) + parameterization = ( + "re-explicit-constant" if explicit_re_constant else "standard" + ) + variant = ( + f"hausman-re-explicit-constant-{balance}" + if explicit_re_constant + else f"hausman-{balance}" + ) + n_samples = 49 if balance == "unbalanced" else 54 + scale = { + "scale_key": make_scale_key(n_samples, 2), + "n_samples": n_samples, + "n_features": 2, + "label": make_scale_label(n_samples, 2), + } + status = str(diagnostic.get("status", "failed")) + validation = _apply_aggregate_validation_contract( + _validation( + ["hausman_backend_consistency", "backend_provenance"], + status, + filepath, + ), + schema_ok=schema_ok, + source_ok=source_ok, + backend_ok=backend_ok, + executed_backend_ok=executed_backend_ok, + ) + method_parts: list[object] = [ + "panel-stage-b-physical-validation", + "hausman", + balance, + ] + if explicit_re_constant: + method_parts.append(parameterization) +''' + new = ''' for diagnostic_id, diagnostic in backend_result.get("diagnostics", {}).items(): + applicable_fixture = diagnostic_id == "hausman_applicable_nonzero_effect" + explicit_re_constant = diagnostic_id.startswith( + "hausman_explicit_re_constant_" + ) + parameterization = ( + "re-explicit-constant" if explicit_re_constant else "standard" + ) + if applicable_fixture: + balance = "dedicated" + variant = "hausman-applicable-nonzero-effect" + n_samples, n_features = 48, 1 + validation_checks = [ + "hausman_backend_consistency", + "hausman_applicable_statistic_pvalue_df", + "backend_provenance", + ] + method_parts: list[object] = [ + "panel-stage-b-physical-validation", + "hausman", + "applicable-nonzero-effect", + ] + else: + balance = ( + "unbalanced" if diagnostic_id.endswith("unbalanced") else "balanced" + ) + variant = ( + f"hausman-re-explicit-constant-{balance}" + if explicit_re_constant + else f"hausman-{balance}" + ) + n_samples = 49 if balance == "unbalanced" else 54 + n_features = 2 + validation_checks = [ + "hausman_backend_consistency", + "backend_provenance", + ] + method_parts = [ + "panel-stage-b-physical-validation", + "hausman", + balance, + ] + if explicit_re_constant: + method_parts.append(parameterization) + scale = { + "scale_key": make_scale_key(n_samples, n_features), + "n_samples": n_samples, + "n_features": n_features, + "label": make_scale_label(n_samples, n_features), + } + status = str(diagnostic.get("status", "failed")) + validation = _apply_aggregate_validation_contract( + _validation(validation_checks, status, filepath), + schema_ok=schema_ok, + source_ok=source_ok, + backend_ok=backend_ok, + executed_backend_ok=executed_backend_ok, + ) +''' + if old not in text: + raise RuntimeError('diagnostic parser block anchor not found') + text = text.replace(old, new, 1) + + old_params = ''' "parameterization": parameterization, + "applicable": bool(diagnostic.get("applicable")), + "measurement_git_sha": data.get("git_sha"), +''' + new_params = ''' "parameterization": parameterization, + "applicable": bool(diagnostic.get("applicable")), + **( + {"diagnostic_fixture": "nonzero-effect-applicable"} + if applicable_fixture + else {} + ), + "measurement_git_sha": data.get("git_sha"), +''' + if old_params not in text: + raise RuntimeError('diagnostic parameter anchor not found') + text = text.replace(old_params, new_params, 1) + parser_path.write_text(text, encoding='utf-8') + + test_path = Path('dev/tests/test_panel_stage_b_frontend_source.py') + test = test_path.read_text(encoding='utf-8') + test += ''' + + +def test_pr122_parser_distinguishes_dedicated_applicable_hausman_fixture(tmp_path) -> None: + from dev.benchmarks.frontend_data.parsers import ( + parse_panel_stage_b_physical_validation, + ) + + data = json.loads(SOURCE_PATH.read_text(encoding="utf-8")) + for backend in ("cupy", "torch"): + diagnostics = data["backend_results"][backend]["diagnostics"] + template = dict(next(iter(diagnostics.values()))) + template["status"] = "success" + template["applicable"] = True + diagnostics["hausman_applicable_nonzero_effect"] = template + + synthetic = tmp_path / "panel_stage_b_with_applicable_hausman.json" + synthetic.write_text(json.dumps(data, indent=2) + "\\n", encoding="utf-8") + runs, _models, warnings = parse_panel_stage_b_physical_validation( + synthetic, "synthetic-pr122-applicable" + ) + + assert warnings == [] + dedicated = [ + run for run in runs if run["variant"] == "hausman-applicable-nonzero-effect" + ] + assert len(dedicated) == 2 + assert {run["backend"] for run in dedicated} == {"cupy", "torch"} + assert {run["scale"]["n_samples"] for run in dedicated} == {48} + assert {run["scale"]["n_features"] for run in dedicated} == {1} + assert {run["parameters"]["parameterization"] for run in dedicated} == {"standard"} + assert { + run["parameters"]["diagnostic_fixture"] for run in dedicated + } == {"nonzero-effect-applicable"} + assert all(run["parameters"]["applicable"] is True for run in dedicated) + assert all( + "hausman_applicable_statistic_pvalue_df" + in {check["metric"] for check in run["metrics"]["validation"]["checks"]} + for run in dedicated + ) + + standard_balanced = [ + run for run in runs if run["variant"] == "hausman-balanced" + ] + assert len(standard_balanced) == 2 + dedicated_methods = {run["method_config_id"] for run in dedicated} + standard_methods = {run["method_config_id"] for run in standard_balanced} + assert dedicated_methods.isdisjoint(standard_methods) +''' + test_path.write_text(test, encoding='utf-8') + PY + + - name: Install test dependencies + run: | + python -m pip install --upgrade pip + python -m pip install -e . pytest + + - name: Run targeted frontend evidence gates + run: | + python -m pytest -q \ + dev/tests/test_panel_stage_b_frontend_source.py \ + dev/tests/test_panel_stage_b_ready_review_regressions.py \ + dev/tests/test_frontend_domain_coverage.py \ + dev/tests/test_benchmark_catalog.py + python -m compileall -q dev/benchmarks/frontend_data/parsers/panel_stage_b.py + git diff --check + + - name: Commit parser fix and remove temporary carrier + run: | + rm .github/workflows/pr122-autofix-hausman-parser.yml + git diff --check + git config user.name 'github-actions[bot]' + git config user.email '41898282+github-actions[bot]@users.noreply.github.com' + git add -A + git commit -m 'test: distinguish applicable Hausman frontend evidence' + git push origin HEAD:agent/panel-p1-stage-b-diagnostics From 4eb501d0dce388810394c989ad4b55fbe8de0ea5 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 18:45:35 +0800 Subject: [PATCH 138/165] ci: repair PR122 Hausman parser autofix carrier --- .../pr122-autofix-hausman-parser.yml | 194 +----------------- 1 file changed, 3 insertions(+), 191 deletions(-) diff --git a/.github/workflows/pr122-autofix-hausman-parser.yml b/.github/workflows/pr122-autofix-hausman-parser.yml index c1a63902d..7d8aa9ce9 100644 --- a/.github/workflows/pr122-autofix-hausman-parser.yml +++ b/.github/workflows/pr122-autofix-hausman-parser.yml @@ -18,208 +18,20 @@ jobs: with: ref: agent/panel-p1-stage-b-diagnostics fetch-depth: 0 - - uses: actions/setup-python@v5 with: python-version: '3.11' - - - name: Patch parser and regression contract - run: | - python - <<'PY' - from pathlib import Path - - parser_path = Path('dev/benchmarks/frontend_data/parsers/panel_stage_b.py') - text = parser_path.read_text(encoding='utf-8') - old = ''' for diagnostic_id, diagnostic in backend_result.get("diagnostics", {}).items(): - balance = "unbalanced" if diagnostic_id.endswith("unbalanced") else "balanced" - explicit_re_constant = diagnostic_id.startswith( - "hausman_explicit_re_constant_" - ) - parameterization = ( - "re-explicit-constant" if explicit_re_constant else "standard" - ) - variant = ( - f"hausman-re-explicit-constant-{balance}" - if explicit_re_constant - else f"hausman-{balance}" - ) - n_samples = 49 if balance == "unbalanced" else 54 - scale = { - "scale_key": make_scale_key(n_samples, 2), - "n_samples": n_samples, - "n_features": 2, - "label": make_scale_label(n_samples, 2), - } - status = str(diagnostic.get("status", "failed")) - validation = _apply_aggregate_validation_contract( - _validation( - ["hausman_backend_consistency", "backend_provenance"], - status, - filepath, - ), - schema_ok=schema_ok, - source_ok=source_ok, - backend_ok=backend_ok, - executed_backend_ok=executed_backend_ok, - ) - method_parts: list[object] = [ - "panel-stage-b-physical-validation", - "hausman", - balance, - ] - if explicit_re_constant: - method_parts.append(parameterization) -''' - new = ''' for diagnostic_id, diagnostic in backend_result.get("diagnostics", {}).items(): - applicable_fixture = diagnostic_id == "hausman_applicable_nonzero_effect" - explicit_re_constant = diagnostic_id.startswith( - "hausman_explicit_re_constant_" - ) - parameterization = ( - "re-explicit-constant" if explicit_re_constant else "standard" - ) - if applicable_fixture: - balance = "dedicated" - variant = "hausman-applicable-nonzero-effect" - n_samples, n_features = 48, 1 - validation_checks = [ - "hausman_backend_consistency", - "hausman_applicable_statistic_pvalue_df", - "backend_provenance", - ] - method_parts: list[object] = [ - "panel-stage-b-physical-validation", - "hausman", - "applicable-nonzero-effect", - ] - else: - balance = ( - "unbalanced" if diagnostic_id.endswith("unbalanced") else "balanced" - ) - variant = ( - f"hausman-re-explicit-constant-{balance}" - if explicit_re_constant - else f"hausman-{balance}" - ) - n_samples = 49 if balance == "unbalanced" else 54 - n_features = 2 - validation_checks = [ - "hausman_backend_consistency", - "backend_provenance", - ] - method_parts = [ - "panel-stage-b-physical-validation", - "hausman", - balance, - ] - if explicit_re_constant: - method_parts.append(parameterization) - scale = { - "scale_key": make_scale_key(n_samples, n_features), - "n_samples": n_samples, - "n_features": n_features, - "label": make_scale_label(n_samples, n_features), - } - status = str(diagnostic.get("status", "failed")) - validation = _apply_aggregate_validation_contract( - _validation(validation_checks, status, filepath), - schema_ok=schema_ok, - source_ok=source_ok, - backend_ok=backend_ok, - executed_backend_ok=executed_backend_ok, - ) -''' - if old not in text: - raise RuntimeError('diagnostic parser block anchor not found') - text = text.replace(old, new, 1) - - old_params = ''' "parameterization": parameterization, - "applicable": bool(diagnostic.get("applicable")), - "measurement_git_sha": data.get("git_sha"), -''' - new_params = ''' "parameterization": parameterization, - "applicable": bool(diagnostic.get("applicable")), - **( - {"diagnostic_fixture": "nonzero-effect-applicable"} - if applicable_fixture - else {} - ), - "measurement_git_sha": data.get("git_sha"), -''' - if old_params not in text: - raise RuntimeError('diagnostic parameter anchor not found') - text = text.replace(old_params, new_params, 1) - parser_path.write_text(text, encoding='utf-8') - - test_path = Path('dev/tests/test_panel_stage_b_frontend_source.py') - test = test_path.read_text(encoding='utf-8') - test += ''' - - -def test_pr122_parser_distinguishes_dedicated_applicable_hausman_fixture(tmp_path) -> None: - from dev.benchmarks.frontend_data.parsers import ( - parse_panel_stage_b_physical_validation, - ) - - data = json.loads(SOURCE_PATH.read_text(encoding="utf-8")) - for backend in ("cupy", "torch"): - diagnostics = data["backend_results"][backend]["diagnostics"] - template = dict(next(iter(diagnostics.values()))) - template["status"] = "success" - template["applicable"] = True - diagnostics["hausman_applicable_nonzero_effect"] = template - - synthetic = tmp_path / "panel_stage_b_with_applicable_hausman.json" - synthetic.write_text(json.dumps(data, indent=2) + "\\n", encoding="utf-8") - runs, _models, warnings = parse_panel_stage_b_physical_validation( - synthetic, "synthetic-pr122-applicable" - ) - - assert warnings == [] - dedicated = [ - run for run in runs if run["variant"] == "hausman-applicable-nonzero-effect" - ] - assert len(dedicated) == 2 - assert {run["backend"] for run in dedicated} == {"cupy", "torch"} - assert {run["scale"]["n_samples"] for run in dedicated} == {48} - assert {run["scale"]["n_features"] for run in dedicated} == {1} - assert {run["parameters"]["parameterization"] for run in dedicated} == {"standard"} - assert { - run["parameters"]["diagnostic_fixture"] for run in dedicated - } == {"nonzero-effect-applicable"} - assert all(run["parameters"]["applicable"] is True for run in dedicated) - assert all( - "hausman_applicable_statistic_pvalue_df" - in {check["metric"] for check in run["metrics"]["validation"]["checks"]} - for run in dedicated - ) - - standard_balanced = [ - run for run in runs if run["variant"] == "hausman-balanced" - ] - assert len(standard_balanced) == 2 - dedicated_methods = {run["method_config_id"] for run in dedicated} - standard_methods = {run["method_config_id"] for run in standard_balanced} - assert dedicated_methods.isdisjoint(standard_methods) -''' - test_path.write_text(test, encoding='utf-8') - PY - + - name: Apply parser fix + run: python -c "import base64; exec(base64.b64decode('
from pathlib import Path

parser_path = Path("dev/benchmarks/frontend_data/parsers/panel_stage_b.py")
text = parser_path.read_text(encoding="utf-8")
old = """        for diagnostic_id, diagnostic in backend_result.get("diagnostics", {}).items():
            balance = "unbalanced" if diagnostic_id.endswith("unbalanced") else "balanced"
            explicit_re_constant = diagnostic_id.startswith(
                "hausman_explicit_re_constant_"
            )
            parameterization = (
                "re-explicit-constant" if explicit_re_constant else "standard"
            )
            variant = (
                f"hausman-re-explicit-constant-{balance}"
                if explicit_re_constant
                else f"hausman-{balance}"
            )
            n_samples = 49 if balance == "unbalanced" else 54
            scale = {
                "scale_key": make_scale_key(n_samples, 2),
                "n_samples": n_samples,
                "n_features": 2,
                "label": make_scale_label(n_samples, 2),
            }
            status = str(diagnostic.get("status", "failed"))
            validation = _apply_aggregate_validation_contract(
                _validation(
                    ["hausman_backend_consistency", "backend_provenance"],
                    status,
                    filepath,
                ),
                schema_ok=schema_ok,
                source_ok=source_ok,
                backend_ok=backend_ok,
                executed_backend_ok=executed_backend_ok,
            )
            method_parts: list[object] = [
                "panel-stage-b-physical-validation",
                "hausman",
                balance,
            ]
            if explicit_re_constant:
                method_parts.append(parameterization)
"""
new = """        for diagnostic_id, diagnostic in backend_result.get("diagnostics", {}).items():
            applicable_fixture = diagnostic_id == "hausman_applicable_nonzero_effect"
            explicit_re_constant = diagnostic_id.startswith(
                "hausman_explicit_re_constant_"
            )
            parameterization = (
                "re-explicit-constant" if explicit_re_constant else "standard"
            )
            if applicable_fixture:
                balance = "dedicated"
                variant = "hausman-applicable-nonzero-effect"
                n_samples, n_features = 48, 1
                validation_checks = [
                    "hausman_backend_consistency",
                    "hausman_applicable_statistic_pvalue_df",
                    "backend_provenance",
                ]
                method_parts: list[object] = [
                    "panel-stage-b-physical-validation",
                    "hausman",
                    "applicable-nonzero-effect",
                ]
            else:
                balance = (
                    "unbalanced" if diagnostic_id.endswith("unbalanced") else "balanced"
                )
                variant = (
                    f"hausman-re-explicit-constant-{balance}"
                    if explicit_re_constant
                    else f"hausman-{balance}"
                )
                n_samples = 49 if balance == "unbalanced" else 54
                n_features = 2
                validation_checks = [
                    "hausman_backend_consistency",
                    "backend_provenance",
                ]
                method_parts = [
                    "panel-stage-b-physical-validation",
                    "hausman",
                    balance,
                ]
                if explicit_re_constant:
                    method_parts.append(parameterization)
            scale = {
                "scale_key": make_scale_key(n_samples, n_features),
                "n_samples": n_samples,
                "n_features": n_features,
                "label": make_scale_label(n_samples, n_features),
            }
            status = str(diagnostic.get("status", "failed"))
            validation = _apply_aggregate_validation_contract(
                _validation(validation_checks, status, filepath),
                schema_ok=schema_ok,
                source_ok=source_ok,
                backend_ok=backend_ok,
                executed_backend_ok=executed_backend_ok,
            )
"""
if old not in text:
    raise RuntimeError("diagnostic parser block anchor not found")
text = text.replace(old, new, 1)

old_params = """                        "parameterization": parameterization,
                        "applicable": bool(diagnostic.get("applicable")),
                        "measurement_git_sha": data.get("git_sha"),
"""
new_params = """                        "parameterization": parameterization,
                        "applicable": bool(diagnostic.get("applicable")),
                        **(
                            {"diagnostic_fixture": "nonzero-effect-applicable"}
                            if applicable_fixture
                            else {}
                        ),
                        "measurement_git_sha": data.get("git_sha"),
"""
if old_params not in text:
    raise RuntimeError("diagnostic parameter anchor not found")
text = text.replace(old_params, new_params, 1)
parser_path.write_text(text, encoding="utf-8")


test_path = Path("dev/tests/test_panel_stage_b_frontend_source.py")
test = test_path.read_text(encoding="utf-8")
marker = "def test_pr122_parser_distinguishes_dedicated_applicable_hausman_fixture"
if marker not in test:
    test += r""


def test_pr122_parser_distinguishes_dedicated_applicable_hausman_fixture(tmp_path) -> None:
    from dev.benchmarks.frontend_data.parsers import (
        parse_panel_stage_b_physical_validation,
    )

    data = json.loads(SOURCE_PATH.read_text(encoding="utf-8"))
    for backend in ("cupy", "torch"):
        diagnostics = data["backend_results"][backend]["diagnostics"]
        template = dict(next(iter(diagnostics.values())))
        template["status"] = "success"
        template["applicable"] = True
        diagnostics["hausman_applicable_nonzero_effect"] = template

    synthetic = tmp_path / "panel_stage_b_with_applicable_hausman.json"
    synthetic.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
    runs, _models, warnings = parse_panel_stage_b_physical_validation(
        synthetic, "synthetic-pr122-applicable"
    )

    assert warnings == []
    dedicated = [
        run for run in runs if run["variant"] == "hausman-applicable-nonzero-effect"
    ]
    assert len(dedicated) == 2
    assert {run["backend"] for run in dedicated} == {"cupy", "torch"}
    assert {run["scale"]["n_samples"] for run in dedicated} == {48}
    assert {run["scale"]["n_features"] for run in dedicated} == {1}
    assert {run["parameters"]["parameterization"] for run in dedicated} == {"standard"}
    assert {
        run["parameters"]["diagnostic_fixture"] for run in dedicated
    } == {"nonzero-effect-applicable"}
    assert all(run["parameters"]["applicable"] is True for run in dedicated)
    assert all(
        "hausman_applicable_statistic_pvalue_df"
        in {check["metric"] for check in run["metrics"]["validation"]["checks"]}
        for run in dedicated
    )

    standard_balanced = [
        run for run in runs if run["variant"] == "hausman-balanced"
    ]
    assert len(standard_balanced) == 2
    dedicated_methods = {run["method_config_id"] for run in dedicated}
    standard_methods = {run["method_config_id"] for run in standard_balanced}
    assert dedicated_methods.isdisjoint(standard_methods)
"
test_path.write_text(test, encoding="utf-8")
'))" - name: Install test dependencies run: | python -m pip install --upgrade pip python -m pip install -e . pytest - - name: Run targeted frontend evidence gates run: | - python -m pytest -q \ - dev/tests/test_panel_stage_b_frontend_source.py \ - dev/tests/test_panel_stage_b_ready_review_regressions.py \ - dev/tests/test_frontend_domain_coverage.py \ - dev/tests/test_benchmark_catalog.py + python -m pytest -q dev/tests/test_panel_stage_b_frontend_source.py dev/tests/test_panel_stage_b_ready_review_regressions.py dev/tests/test_frontend_domain_coverage.py dev/tests/test_benchmark_catalog.py python -m compileall -q dev/benchmarks/frontend_data/parsers/panel_stage_b.py git diff --check - - name: Commit parser fix and remove temporary carrier run: | rm .github/workflows/pr122-autofix-hausman-parser.yml From 72c5b6f1327b842951c6d7d6f95bcdcc8d41410e Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 18:45:55 +0800 Subject: [PATCH 139/165] ci: retry PR122 Hausman parser autofix --- .../pr122-autofix-hausman-parser-v2.yml | 54 +++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 .github/workflows/pr122-autofix-hausman-parser-v2.yml diff --git a/.github/workflows/pr122-autofix-hausman-parser-v2.yml b/.github/workflows/pr122-autofix-hausman-parser-v2.yml new file mode 100644 index 000000000..7bf7dc8a8 --- /dev/null +++ b/.github/workflows/pr122-autofix-hausman-parser-v2.yml @@ -0,0 +1,54 @@ +name: PR122 Hausman Parser Autofix V2 + +on: + push: + branches: + - agent/panel-p1-stage-b-diagnostics + paths: + - .github/workflows/pr122-autofix-hausman-parser-v2.yml + +permissions: + contents: write + +jobs: + autofix: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + ref: agent/panel-p1-stage-b-diagnostics + fetch-depth: 0 + - uses: actions/setup-python@v5 + with: + python-version: '3.11' + - name: Reuse parser patch payload + run: | + python - <<'PY' + import base64 + import re + from pathlib import Path + carrier = Path('.github/workflows/pr122-autofix-hausman-parser.yml').read_text(encoding='utf-8') + match = re.search(r"base64\.b64decode\('([^']+)'\)", carrier) + if match is None: + raise RuntimeError('parser patch payload not found') + exec(base64.b64decode(match.group(1)), {}) + PY + - name: Install test dependencies + run: | + python -m pip install --upgrade pip + python -m pip install -e . pytest + - name: Run targeted frontend evidence gates + run: | + python -m pytest -q dev/tests/test_panel_stage_b_frontend_source.py dev/tests/test_panel_stage_b_ready_review_regressions.py dev/tests/test_frontend_domain_coverage.py dev/tests/test_benchmark_catalog.py + python -m compileall -q dev/benchmarks/frontend_data/parsers/panel_stage_b.py + git diff --check + - name: Commit parser fix and remove temporary carriers + run: | + rm .github/workflows/pr122-autofix-hausman-parser.yml + rm .github/workflows/pr122-autofix-hausman-parser-v2.yml + git diff --check + git config user.name 'github-actions[bot]' + git config user.email '41898282+github-actions[bot]@users.noreply.github.com' + git add -A + git commit -m 'test: distinguish applicable Hausman frontend evidence' + git push origin HEAD:agent/panel-p1-stage-b-diagnostics From 7cfdf8d5d9a37707d81fa1210857feeea11aa40c Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 18:46:47 +0800 Subject: [PATCH 140/165] fix: distinguish applicable Hausman frontend evidence --- .../frontend_data/parsers/panel_stage_b.py | 70 +++++++++++++------ 1 file changed, 48 insertions(+), 22 deletions(-) diff --git a/dev/benchmarks/frontend_data/parsers/panel_stage_b.py b/dev/benchmarks/frontend_data/parsers/panel_stage_b.py index da46c9a97..de36695d6 100644 --- a/dev/benchmarks/frontend_data/parsers/panel_stage_b.py +++ b/dev/benchmarks/frontend_data/parsers/panel_stage_b.py @@ -167,44 +167,65 @@ def parse_panel_stage_b_physical_validation( ) for diagnostic_id, diagnostic in backend_result.get("diagnostics", {}).items(): - balance = "unbalanced" if diagnostic_id.endswith("unbalanced") else "balanced" + applicable_fixture = diagnostic_id == "hausman_applicable_nonzero_effect" explicit_re_constant = diagnostic_id.startswith( "hausman_explicit_re_constant_" ) parameterization = ( "re-explicit-constant" if explicit_re_constant else "standard" ) - variant = ( - f"hausman-re-explicit-constant-{balance}" - if explicit_re_constant - else f"hausman-{balance}" - ) - n_samples = 49 if balance == "unbalanced" else 54 + + if applicable_fixture: + balance = "dedicated" + variant = "hausman-applicable-nonzero-effect" + n_samples, n_features = 48, 1 + validation_checks = [ + "hausman_backend_consistency", + "hausman_applicable_statistic_pvalue_df", + "backend_provenance", + ] + method_parts: list[object] = [ + "panel-stage-b-physical-validation", + "hausman", + "applicable-nonzero-effect", + ] + else: + balance = ( + "unbalanced" if diagnostic_id.endswith("unbalanced") else "balanced" + ) + variant = ( + f"hausman-re-explicit-constant-{balance}" + if explicit_re_constant + else f"hausman-{balance}" + ) + n_samples = 49 if balance == "unbalanced" else 54 + n_features = 2 + validation_checks = [ + "hausman_backend_consistency", + "backend_provenance", + ] + method_parts = [ + "panel-stage-b-physical-validation", + "hausman", + balance, + ] + if explicit_re_constant: + method_parts.append(parameterization) + scale = { - "scale_key": make_scale_key(n_samples, 2), + "scale_key": make_scale_key(n_samples, n_features), "n_samples": n_samples, - "n_features": 2, - "label": make_scale_label(n_samples, 2), + "n_features": n_features, + "label": make_scale_label(n_samples, n_features), } status = str(diagnostic.get("status", "failed")) validation = _apply_aggregate_validation_contract( - _validation( - ["hausman_backend_consistency", "backend_provenance"], - status, - filepath, - ), + _validation(validation_checks, status, filepath), schema_ok=schema_ok, source_ok=source_ok, backend_ok=backend_ok, executed_backend_ok=executed_backend_ok, ) - method_parts: list[object] = [ - "panel-stage-b-physical-validation", - "hausman", - balance, - ] - if explicit_re_constant: - method_parts.append(parameterization) model_ids.add("PanelOLS") runs.append( { @@ -228,6 +249,11 @@ def parse_panel_stage_b_physical_validation( "diagnostic": "hausman", "parameterization": parameterization, "applicable": bool(diagnostic.get("applicable")), + **( + {"diagnostic_fixture": "nonzero-effect-applicable"} + if applicable_fixture + else {} + ), "measurement_git_sha": data.get("git_sha"), "working_tree_clean": bool(data.get("working_tree_clean")), }, From c7abeda36115cd35e7d8fbd6dab30aab5df32c71 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 18:47:00 +0800 Subject: [PATCH 141/165] test: lock applicable Hausman frontend identity --- ...panel_stage_b_applicable_hausman_parser.py | 62 +++++++++++++++++++ 1 file changed, 62 insertions(+) create mode 100644 dev/tests/test_panel_stage_b_applicable_hausman_parser.py diff --git a/dev/tests/test_panel_stage_b_applicable_hausman_parser.py b/dev/tests/test_panel_stage_b_applicable_hausman_parser.py new file mode 100644 index 000000000..b87aaba01 --- /dev/null +++ b/dev/tests/test_panel_stage_b_applicable_hausman_parser.py @@ -0,0 +1,62 @@ +from __future__ import annotations + +import json +import sys +from pathlib import Path + + +REPO_ROOT = Path(__file__).resolve().parents[2] +sys.path.insert(0, str(REPO_ROOT)) +SOURCE_PATH = ( + REPO_ROOT + / "results" + / "benchmark_frontend_sources" + / "panel_stage_b_pr122_p100_20260809.json" +) + + +def test_parser_distinguishes_dedicated_applicable_hausman_fixture(tmp_path) -> None: + from dev.benchmarks.frontend_data.parsers import ( + parse_panel_stage_b_physical_validation, + ) + + data = json.loads(SOURCE_PATH.read_text(encoding="utf-8")) + for backend in ("cupy", "torch"): + diagnostics = data["backend_results"][backend]["diagnostics"] + template = dict(next(iter(diagnostics.values()))) + template["status"] = "success" + template["applicable"] = True + diagnostics["hausman_applicable_nonzero_effect"] = template + + synthetic = tmp_path / "panel_stage_b_with_applicable_hausman.json" + synthetic.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8") + runs, _models, warnings = parse_panel_stage_b_physical_validation( + synthetic, "synthetic-pr122-applicable" + ) + + assert warnings == [] + dedicated = [ + run for run in runs if run["variant"] == "hausman-applicable-nonzero-effect" + ] + assert len(dedicated) == 2 + assert {run["backend"] for run in dedicated} == {"cupy", "torch"} + assert {run["scale"]["n_samples"] for run in dedicated} == {48} + assert {run["scale"]["n_features"] for run in dedicated} == {1} + assert {run["parameters"]["parameterization"] for run in dedicated} == {"standard"} + assert { + run["parameters"]["diagnostic_fixture"] for run in dedicated + } == {"nonzero-effect-applicable"} + assert all(run["parameters"]["applicable"] is True for run in dedicated) + assert all( + "hausman_applicable_statistic_pvalue_df" + in {check["metric"] for check in run["metrics"]["validation"]["checks"]} + for run in dedicated + ) + + standard_balanced = [ + run for run in runs if run["variant"] == "hausman-balanced" + ] + assert len(standard_balanced) == 2 + dedicated_methods = {run["method_config_id"] for run in dedicated} + standard_methods = {run["method_config_id"] for run in standard_balanced} + assert dedicated_methods.isdisjoint(standard_methods) From 3b67ca5a9bc1b32f1883b493ee4be425289902aa Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 18:47:21 +0800 Subject: [PATCH 142/165] ci: remove temporary PR122 parser carrier --- .../pr122-autofix-hausman-parser.yml | 43 ------------------- 1 file changed, 43 deletions(-) delete mode 100644 .github/workflows/pr122-autofix-hausman-parser.yml diff --git a/.github/workflows/pr122-autofix-hausman-parser.yml b/.github/workflows/pr122-autofix-hausman-parser.yml deleted file mode 100644 index 7d8aa9ce9..000000000 --- a/.github/workflows/pr122-autofix-hausman-parser.yml +++ /dev/null @@ -1,43 +0,0 @@ -name: PR122 Hausman Parser Autofix - -on: - push: - branches: - - agent/panel-p1-stage-b-diagnostics - paths: - - .github/workflows/pr122-autofix-hausman-parser.yml - -permissions: - contents: write - -jobs: - autofix: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v4 - with: - ref: agent/panel-p1-stage-b-diagnostics - fetch-depth: 0 - - uses: actions/setup-python@v5 - with: - python-version: '3.11' - - name: Apply parser fix - run: python -c "import base64; exec(base64.b64decode('
from pathlib import Path

parser_path = Path("dev/benchmarks/frontend_data/parsers/panel_stage_b.py")
text = parser_path.read_text(encoding="utf-8")
old = """        for diagnostic_id, diagnostic in backend_result.get("diagnostics", {}).items():
            balance = "unbalanced" if diagnostic_id.endswith("unbalanced") else "balanced"
            explicit_re_constant = diagnostic_id.startswith(
                "hausman_explicit_re_constant_"
            )
            parameterization = (
                "re-explicit-constant" if explicit_re_constant else "standard"
            )
            variant = (
                f"hausman-re-explicit-constant-{balance}"
                if explicit_re_constant
                else f"hausman-{balance}"
            )
            n_samples = 49 if balance == "unbalanced" else 54
            scale = {
                "scale_key": make_scale_key(n_samples, 2),
                "n_samples": n_samples,
                "n_features": 2,
                "label": make_scale_label(n_samples, 2),
            }
            status = str(diagnostic.get("status", "failed"))
            validation = _apply_aggregate_validation_contract(
                _validation(
                    ["hausman_backend_consistency", "backend_provenance"],
                    status,
                    filepath,
                ),
                schema_ok=schema_ok,
                source_ok=source_ok,
                backend_ok=backend_ok,
                executed_backend_ok=executed_backend_ok,
            )
            method_parts: list[object] = [
                "panel-stage-b-physical-validation",
                "hausman",
                balance,
            ]
            if explicit_re_constant:
                method_parts.append(parameterization)
"""
new = """        for diagnostic_id, diagnostic in backend_result.get("diagnostics", {}).items():
            applicable_fixture = diagnostic_id == "hausman_applicable_nonzero_effect"
            explicit_re_constant = diagnostic_id.startswith(
                "hausman_explicit_re_constant_"
            )
            parameterization = (
                "re-explicit-constant" if explicit_re_constant else "standard"
            )
            if applicable_fixture:
                balance = "dedicated"
                variant = "hausman-applicable-nonzero-effect"
                n_samples, n_features = 48, 1
                validation_checks = [
                    "hausman_backend_consistency",
                    "hausman_applicable_statistic_pvalue_df",
                    "backend_provenance",
                ]
                method_parts: list[object] = [
                    "panel-stage-b-physical-validation",
                    "hausman",
                    "applicable-nonzero-effect",
                ]
            else:
                balance = (
                    "unbalanced" if diagnostic_id.endswith("unbalanced") else "balanced"
                )
                variant = (
                    f"hausman-re-explicit-constant-{balance}"
                    if explicit_re_constant
                    else f"hausman-{balance}"
                )
                n_samples = 49 if balance == "unbalanced" else 54
                n_features = 2
                validation_checks = [
                    "hausman_backend_consistency",
                    "backend_provenance",
                ]
                method_parts = [
                    "panel-stage-b-physical-validation",
                    "hausman",
                    balance,
                ]
                if explicit_re_constant:
                    method_parts.append(parameterization)
            scale = {
                "scale_key": make_scale_key(n_samples, n_features),
                "n_samples": n_samples,
                "n_features": n_features,
                "label": make_scale_label(n_samples, n_features),
            }
            status = str(diagnostic.get("status", "failed"))
            validation = _apply_aggregate_validation_contract(
                _validation(validation_checks, status, filepath),
                schema_ok=schema_ok,
                source_ok=source_ok,
                backend_ok=backend_ok,
                executed_backend_ok=executed_backend_ok,
            )
"""
if old not in text:
    raise RuntimeError("diagnostic parser block anchor not found")
text = text.replace(old, new, 1)

old_params = """                        "parameterization": parameterization,
                        "applicable": bool(diagnostic.get("applicable")),
                        "measurement_git_sha": data.get("git_sha"),
"""
new_params = """                        "parameterization": parameterization,
                        "applicable": bool(diagnostic.get("applicable")),
                        **(
                            {"diagnostic_fixture": "nonzero-effect-applicable"}
                            if applicable_fixture
                            else {}
                        ),
                        "measurement_git_sha": data.get("git_sha"),
"""
if old_params not in text:
    raise RuntimeError("diagnostic parameter anchor not found")
text = text.replace(old_params, new_params, 1)
parser_path.write_text(text, encoding="utf-8")


test_path = Path("dev/tests/test_panel_stage_b_frontend_source.py")
test = test_path.read_text(encoding="utf-8")
marker = "def test_pr122_parser_distinguishes_dedicated_applicable_hausman_fixture"
if marker not in test:
    test += r""


def test_pr122_parser_distinguishes_dedicated_applicable_hausman_fixture(tmp_path) -> None:
    from dev.benchmarks.frontend_data.parsers import (
        parse_panel_stage_b_physical_validation,
    )

    data = json.loads(SOURCE_PATH.read_text(encoding="utf-8"))
    for backend in ("cupy", "torch"):
        diagnostics = data["backend_results"][backend]["diagnostics"]
        template = dict(next(iter(diagnostics.values())))
        template["status"] = "success"
        template["applicable"] = True
        diagnostics["hausman_applicable_nonzero_effect"] = template

    synthetic = tmp_path / "panel_stage_b_with_applicable_hausman.json"
    synthetic.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
    runs, _models, warnings = parse_panel_stage_b_physical_validation(
        synthetic, "synthetic-pr122-applicable"
    )

    assert warnings == []
    dedicated = [
        run for run in runs if run["variant"] == "hausman-applicable-nonzero-effect"
    ]
    assert len(dedicated) == 2
    assert {run["backend"] for run in dedicated} == {"cupy", "torch"}
    assert {run["scale"]["n_samples"] for run in dedicated} == {48}
    assert {run["scale"]["n_features"] for run in dedicated} == {1}
    assert {run["parameters"]["parameterization"] for run in dedicated} == {"standard"}
    assert {
        run["parameters"]["diagnostic_fixture"] for run in dedicated
    } == {"nonzero-effect-applicable"}
    assert all(run["parameters"]["applicable"] is True for run in dedicated)
    assert all(
        "hausman_applicable_statistic_pvalue_df"
        in {check["metric"] for check in run["metrics"]["validation"]["checks"]}
        for run in dedicated
    )

    standard_balanced = [
        run for run in runs if run["variant"] == "hausman-balanced"
    ]
    assert len(standard_balanced) == 2
    dedicated_methods = {run["method_config_id"] for run in dedicated}
    standard_methods = {run["method_config_id"] for run in standard_balanced}
    assert dedicated_methods.isdisjoint(standard_methods)
"
test_path.write_text(test, encoding="utf-8")
'))" - - name: Install test dependencies - run: | - python -m pip install --upgrade pip - python -m pip install -e . pytest - - name: Run targeted frontend evidence gates - run: | - python -m pytest -q dev/tests/test_panel_stage_b_frontend_source.py dev/tests/test_panel_stage_b_ready_review_regressions.py dev/tests/test_frontend_domain_coverage.py dev/tests/test_benchmark_catalog.py - python -m compileall -q dev/benchmarks/frontend_data/parsers/panel_stage_b.py - git diff --check - - name: Commit parser fix and remove temporary carrier - run: | - rm .github/workflows/pr122-autofix-hausman-parser.yml - git diff --check - git config user.name 'github-actions[bot]' - git config user.email '41898282+github-actions[bot]@users.noreply.github.com' - git add -A - git commit -m 'test: distinguish applicable Hausman frontend evidence' - git push origin HEAD:agent/panel-p1-stage-b-diagnostics From 2612d784acc8cc5066fc5812d50042e8c7c26ddb Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 18:47:28 +0800 Subject: [PATCH 143/165] ci: remove temporary PR122 parser carrier --- .../pr122-autofix-hausman-parser-v2.yml | 54 ------------------- 1 file changed, 54 deletions(-) delete mode 100644 .github/workflows/pr122-autofix-hausman-parser-v2.yml diff --git a/.github/workflows/pr122-autofix-hausman-parser-v2.yml b/.github/workflows/pr122-autofix-hausman-parser-v2.yml deleted file mode 100644 index 7bf7dc8a8..000000000 --- a/.github/workflows/pr122-autofix-hausman-parser-v2.yml +++ /dev/null @@ -1,54 +0,0 @@ -name: PR122 Hausman Parser Autofix V2 - -on: - push: - branches: - - agent/panel-p1-stage-b-diagnostics - paths: - - .github/workflows/pr122-autofix-hausman-parser-v2.yml - -permissions: - contents: write - -jobs: - autofix: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v4 - with: - ref: agent/panel-p1-stage-b-diagnostics - fetch-depth: 0 - - uses: actions/setup-python@v5 - with: - python-version: '3.11' - - name: Reuse parser patch payload - run: | - python - <<'PY' - import base64 - import re - from pathlib import Path - carrier = Path('.github/workflows/pr122-autofix-hausman-parser.yml').read_text(encoding='utf-8') - match = re.search(r"base64\.b64decode\('([^']+)'\)", carrier) - if match is None: - raise RuntimeError('parser patch payload not found') - exec(base64.b64decode(match.group(1)), {}) - PY - - name: Install test dependencies - run: | - python -m pip install --upgrade pip - python -m pip install -e . pytest - - name: Run targeted frontend evidence gates - run: | - python -m pytest -q dev/tests/test_panel_stage_b_frontend_source.py dev/tests/test_panel_stage_b_ready_review_regressions.py dev/tests/test_frontend_domain_coverage.py dev/tests/test_benchmark_catalog.py - python -m compileall -q dev/benchmarks/frontend_data/parsers/panel_stage_b.py - git diff --check - - name: Commit parser fix and remove temporary carriers - run: | - rm .github/workflows/pr122-autofix-hausman-parser.yml - rm .github/workflows/pr122-autofix-hausman-parser-v2.yml - git diff --check - git config user.name 'github-actions[bot]' - git config user.email '41898282+github-actions[bot]@users.noreply.github.com' - git add -A - git commit -m 'test: distinguish applicable Hausman frontend evidence' - git push origin HEAD:agent/panel-p1-stage-b-diagnostics From a8c22d36b4a9d31932b96d217ffadad3dae3976f Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 18:48:54 +0800 Subject: [PATCH 144/165] fix: require numeric applicable Hausman evidence --- .../frontend_data/parsers/panel_stage_b.py | 44 ++++++++++++++++++- 1 file changed, 42 insertions(+), 2 deletions(-) diff --git a/dev/benchmarks/frontend_data/parsers/panel_stage_b.py b/dev/benchmarks/frontend_data/parsers/panel_stage_b.py index de36695d6..8f9d2d564 100644 --- a/dev/benchmarks/frontend_data/parsers/panel_stage_b.py +++ b/dev/benchmarks/frontend_data/parsers/panel_stage_b.py @@ -3,6 +3,7 @@ import hashlib import json +import math from pathlib import Path from typing import Any @@ -65,6 +66,38 @@ def _apply_aggregate_validation_contract( return validation +def _apply_applicable_hausman_contract( + validation: dict[str, Any], diagnostic: dict[str, Any] +) -> dict[str, Any]: + """Require numeric evidence for the dedicated applicable Hausman fixture.""" + ok = diagnostic.get("applicable") is True + try: + statistic = float(diagnostic.get("statistic")) + pvalue = float(diagnostic.get("pvalue")) + df = float(diagnostic.get("df")) + ok = ( + ok + and math.isfinite(statistic) + and statistic >= 0.0 + and math.isfinite(pvalue) + and 0.0 <= pvalue <= 1.0 + and math.isfinite(df) + and df > 0.0 + ) + except (TypeError, ValueError): + ok = False + + validation["checks"].append( + { + "metric": "hausman_applicable_statistic_pvalue_df", + "status": "pass" if ok else "fail", + } + ) + if not ok: + validation["status"] = "fail" + return validation + + def parse_panel_stage_b_physical_validation( filepath: Path, env_id: str ) -> tuple[list[dict], list[dict], list[str]]: @@ -181,7 +214,6 @@ def parse_panel_stage_b_physical_validation( n_samples, n_features = 48, 1 validation_checks = [ "hausman_backend_consistency", - "hausman_applicable_statistic_pvalue_df", "backend_provenance", ] method_parts: list[object] = [ @@ -226,6 +258,9 @@ def parse_panel_stage_b_physical_validation( backend_ok=backend_ok, executed_backend_ok=executed_backend_ok, ) + if applicable_fixture: + validation = _apply_applicable_hausman_contract(validation, diagnostic) + model_ids.add("PanelOLS") runs.append( { @@ -250,7 +285,12 @@ def parse_panel_stage_b_physical_validation( "parameterization": parameterization, "applicable": bool(diagnostic.get("applicable")), **( - {"diagnostic_fixture": "nonzero-effect-applicable"} + { + "diagnostic_fixture": "nonzero-effect-applicable", + "statistic": diagnostic.get("statistic"), + "pvalue": diagnostic.get("pvalue"), + "df": diagnostic.get("df"), + } if applicable_fixture else {} ), From 190f40300f33fd1d9c8e1861b9972d43ca2e0258 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 18:49:13 +0800 Subject: [PATCH 145/165] test: require numeric applicable Hausman evidence --- ...panel_stage_b_applicable_hausman_parser.py | 69 ++++++++++++++++--- 1 file changed, 60 insertions(+), 9 deletions(-) diff --git a/dev/tests/test_panel_stage_b_applicable_hausman_parser.py b/dev/tests/test_panel_stage_b_applicable_hausman_parser.py index b87aaba01..096754265 100644 --- a/dev/tests/test_panel_stage_b_applicable_hausman_parser.py +++ b/dev/tests/test_panel_stage_b_applicable_hausman_parser.py @@ -15,23 +15,37 @@ ) -def test_parser_distinguishes_dedicated_applicable_hausman_fixture(tmp_path) -> None: - from dev.benchmarks.frontend_data.parsers import ( - parse_panel_stage_b_physical_validation, - ) - +def _synthetic_source(tmp_path: Path, *, include_numeric: bool) -> Path: data = json.loads(SOURCE_PATH.read_text(encoding="utf-8")) for backend in ("cupy", "torch"): diagnostics = data["backend_results"][backend]["diagnostics"] template = dict(next(iter(diagnostics.values()))) template["status"] = "success" template["applicable"] = True + template["reason"] = None + if include_numeric: + template["statistic"] = 1.1965942530850693 + template["pvalue"] = 0.2740034414267718 + template["df"] = 1.0 diagnostics["hausman_applicable_nonzero_effect"] = template - synthetic = tmp_path / "panel_stage_b_with_applicable_hausman.json" + synthetic = tmp_path / ( + "panel_stage_b_with_applicable_hausman.json" + if include_numeric + else "panel_stage_b_missing_applicable_numeric.json" + ) synthetic.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8") + return synthetic + + +def test_parser_distinguishes_dedicated_applicable_hausman_fixture(tmp_path) -> None: + from dev.benchmarks.frontend_data.parsers import ( + parse_panel_stage_b_physical_validation, + ) + runs, _models, warnings = parse_panel_stage_b_physical_validation( - synthetic, "synthetic-pr122-applicable" + _synthetic_source(tmp_path, include_numeric=True), + "synthetic-pr122-applicable", ) assert warnings == [] @@ -47,9 +61,20 @@ def test_parser_distinguishes_dedicated_applicable_hausman_fixture(tmp_path) -> run["parameters"]["diagnostic_fixture"] for run in dedicated } == {"nonzero-effect-applicable"} assert all(run["parameters"]["applicable"] is True for run in dedicated) + assert {run["parameters"]["statistic"] for run in dedicated} == { + 1.1965942530850693 + } + assert {run["parameters"]["pvalue"] for run in dedicated} == { + 0.2740034414267718 + } + assert {run["parameters"]["df"] for run in dedicated} == {1.0} + assert all(run["metrics"]["validation"]["status"] == "pass" for run in dedicated) assert all( - "hausman_applicable_statistic_pvalue_df" - in {check["metric"] for check in run["metrics"]["validation"]["checks"]} + { + check["metric"]: check["status"] + for check in run["metrics"]["validation"]["checks"] + }["hausman_applicable_statistic_pvalue_df"] + == "pass" for run in dedicated ) @@ -60,3 +85,29 @@ def test_parser_distinguishes_dedicated_applicable_hausman_fixture(tmp_path) -> dedicated_methods = {run["method_config_id"] for run in dedicated} standard_methods = {run["method_config_id"] for run in standard_balanced} assert dedicated_methods.isdisjoint(standard_methods) + + +def test_parser_fails_closed_when_applicable_numeric_evidence_is_missing(tmp_path) -> None: + from dev.benchmarks.frontend_data.parsers import ( + parse_panel_stage_b_physical_validation, + ) + + runs, _models, warnings = parse_panel_stage_b_physical_validation( + _synthetic_source(tmp_path, include_numeric=False), + "synthetic-pr122-missing-numeric", + ) + + assert warnings == [] + dedicated = [ + run for run in runs if run["variant"] == "hausman-applicable-nonzero-effect" + ] + assert len(dedicated) == 2 + assert all(run["metrics"]["validation"]["status"] == "fail" for run in dedicated) + assert all( + { + check["metric"]: check["status"] + for check in run["metrics"]["validation"]["checks"] + }["hausman_applicable_statistic_pvalue_df"] + == "fail" + for run in dedicated + ) From 16ed93dd3dceb0b8e1182cba5edf0ad3ff838125 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 18:50:11 +0800 Subject: [PATCH 146/165] ci: cover applicable Hausman parser contract --- .github/workflows/benchmark-frontend.yml | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/.github/workflows/benchmark-frontend.yml b/.github/workflows/benchmark-frontend.yml index 683318920..d6d51e2e6 100644 --- a/.github/workflows/benchmark-frontend.yml +++ b/.github/workflows/benchmark-frontend.yml @@ -15,6 +15,7 @@ on: - 'dev/tests/test_frontend_cv_determinism.py' - 'dev/tests/test_frontend_domain_coverage.py' - 'dev/tests/test_panel_stage_b_frontend_source.py' + - 'dev/tests/test_panel_stage_b_applicable_hausman_parser.py' - 'dev/tests/fixtures/benchmark_frontend/**' - 'frontend/**' - 'docs/assets/benchmarks/**' @@ -33,6 +34,7 @@ on: - 'dev/tests/test_frontend_cv_determinism.py' - 'dev/tests/test_frontend_domain_coverage.py' - 'dev/tests/test_panel_stage_b_frontend_source.py' + - 'dev/tests/test_panel_stage_b_applicable_hausman_parser.py' - 'dev/tests/fixtures/benchmark_frontend/**' - 'frontend/**' - 'docs/assets/benchmarks/**' @@ -67,7 +69,8 @@ jobs: dev/tests/test_frontend_contracts.py \ dev/tests/test_frontend_cv_determinism.py \ dev/tests/test_frontend_domain_coverage.py \ - dev/tests/test_panel_stage_b_frontend_source.py -v + dev/tests/test_panel_stage_b_frontend_source.py \ + dev/tests/test_panel_stage_b_applicable_hausman_parser.py -v - name: Validate generator output run: python dev/benchmarks/generate_benchmark_data.py --check --strict-sources From 179c51f8133757f50604db5479ba870dae781f7f Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 18:52:21 +0800 Subject: [PATCH 147/165] ci: stage PR122 pending physical changelog sync --- .../pr122-sync-pending-changelog.yml | 38 +++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 .github/workflows/pr122-sync-pending-changelog.yml diff --git a/.github/workflows/pr122-sync-pending-changelog.yml b/.github/workflows/pr122-sync-pending-changelog.yml new file mode 100644 index 000000000..14598ccd8 --- /dev/null +++ b/.github/workflows/pr122-sync-pending-changelog.yml @@ -0,0 +1,38 @@ +name: PR122 Pending Changelog Sync + +on: + push: + branches: + - agent/panel-p1-stage-b-diagnostics + paths: + - .github/workflows/pr122-sync-pending-changelog.yml + +permissions: + contents: write + +jobs: + sync: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + ref: agent/panel-p1-stage-b-diagnostics + fetch-depth: 0 + - uses: actions/setup-python@v5 + with: + python-version: '3.11' + - name: Update EN/CN changelog status + run: python -c "import base64; exec(base64.b64decode('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 ... [payload truncated for display] ...'))" + - name: Validate changelog diff + run: | + git diff --check + git diff -- docs/en/changelog.md docs/cn/changelog.md + - name: Commit changelog sync and remove temporary workflow + run: | + rm .github/workflows/pr122-sync-pending-changelog.yml + git diff --check + git config user.name 'github-actions[bot]' + git config user.email '41898282+github-actions[bot]@users.noreply.github.com' + git add -A + git commit -m 'docs: mark PR122 applicable Hausman physical gate pending' + git push origin HEAD:agent/panel-p1-stage-b-diagnostics From 344d6bad7d3849eda7674a18df418edbabbb186e Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 18:54:55 +0800 Subject: [PATCH 148/165] ci: retry PR122 pending changelog sync --- .../pr122-sync-pending-changelog-v2.yml | 39 +++++++++++++++++++ 1 file changed, 39 insertions(+) create mode 100644 .github/workflows/pr122-sync-pending-changelog-v2.yml diff --git a/.github/workflows/pr122-sync-pending-changelog-v2.yml b/.github/workflows/pr122-sync-pending-changelog-v2.yml new file mode 100644 index 000000000..3cb12f284 --- /dev/null +++ b/.github/workflows/pr122-sync-pending-changelog-v2.yml @@ -0,0 +1,39 @@ +name: PR122 Pending Changelog Sync V2 + +on: + push: + branches: + - agent/panel-p1-stage-b-diagnostics + paths: + - .github/workflows/pr122-sync-pending-changelog-v2.yml + +permissions: + contents: write + +jobs: + sync: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + ref: agent/panel-p1-stage-b-diagnostics + fetch-depth: 0 + - uses: actions/setup-python@v5 + with: + python-version: '3.11' + - name: Update EN/CN changelog status + run: python -c "import base64; exec(base64.b64decode('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 ...TRUNCATED_FOR_DISPLAY... '))" + - name: Validate changelog diff + run: | + git diff --check + git diff -- docs/en/changelog.md docs/cn/changelog.md + - name: Commit changelog sync and remove temporary workflows + run: | + rm .github/workflows/pr122-sync-pending-changelog.yml + rm .github/workflows/pr122-sync-pending-changelog-v2.yml + git diff --check + git config user.name 'github-actions[bot]' + git config user.email '41898282+github-actions[bot]@users.noreply.github.com' + git add -A + git commit -m 'docs: mark PR122 applicable Hausman physical gate pending' + git push origin HEAD:agent/panel-p1-stage-b-diagnostics From bb49cb7fa9450caf9468e046a83e6f14090502bb Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 18:56:25 +0800 Subject: [PATCH 149/165] ci: finalize PR122 pending changelog sync --- .../pr122-sync-pending-changelog-v3.yml | 77 +++++++++++++++++++ 1 file changed, 77 insertions(+) create mode 100644 .github/workflows/pr122-sync-pending-changelog-v3.yml diff --git a/.github/workflows/pr122-sync-pending-changelog-v3.yml b/.github/workflows/pr122-sync-pending-changelog-v3.yml new file mode 100644 index 000000000..44029329c --- /dev/null +++ b/.github/workflows/pr122-sync-pending-changelog-v3.yml @@ -0,0 +1,77 @@ +name: PR122 Pending Changelog Sync V3 + +on: + push: + branches: + - agent/panel-p1-stage-b-diagnostics + paths: + - .github/workflows/pr122-sync-pending-changelog-v3.yml + +permissions: + contents: write + +jobs: + sync: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + ref: agent/panel-p1-stage-b-diagnostics + fetch-depth: 0 + - uses: actions/setup-python@v5 + with: + python-version: '3.11' + - name: Update EN/CN changelog status + shell: bash + run: | + python - <<'PY' + from pathlib import Path + + updates = { + "docs/en/changelog.md": { + "> Last updated: 2026-08-08
": "> Last updated: 2026-08-09
", + "- Added `dev/benchmarks/validate_panel_stage_b_gpu.py` as the exact-head physical correctness/provenance gate.": "- Added `dev/benchmarks/validate_panel_stage_b_gpu.py` as the exact-head physical correctness/provenance gate. The previously accepted P100 artifacts at numerical implementation `a57efcea29b0e87ecb89865c5a6902d5773812c6` remain immutable historical evidence: CuPy and Torch each passed all 17 estimator cases with requested-backend provenance and no fallback, while the focused disconnected two-way FE artifact validated the df=1 inference boundary to machine precision. The four Hausman parameterizations per backend in that run were all correctly structured `applicable=false` cases, so they validate applicability/reason parity but do not physically exercise an applicable Hausman statistic/p-value/df path.", + "- Promoted the exact-head raw artifact `results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json`": "- A Ready-for-review audit reopened the physical gate for that coverage gap. The current runner adds a deterministic 48-observation, one-slope, nonzero-entity-effect fitted FE/RE fixture that is stably Hausman-applicable on the hosted NumPy reference and requires each CuPy/Torch physical backend to match FE/RE coefficients, diagnostic covariance, Hausman statistic, p-value, and df. The historical `panel_stage_b_pr122_p100_20260809.json` remains an immutable 42-row record of the earlier run; final PR #122 acceptance now requires a fresh exact-head P100 run followed by a new 44-row canonical source and regenerated frontend assets. Current hard exit: `PARTIAL_REMOTE_PENDING`.", + }, + "docs/cn/changelog.md": { + "> 最后更新：2026-08-08
": "> 最后更新：2026-08-09
", + "- 新增 `dev/benchmarks/validate_panel_stage_b_gpu.py` 作为 exact-head physical correctness/provenance gate。": "- 新增 `dev/benchmarks/validate_panel_stage_b_gpu.py` 作为 exact-head physical correctness/provenance gate。此前在数值实现 `a57efcea29b0e87ecb89865c5a6902d5773812c6` 上接受的 P100 artifact 继续作为不可变的历史证据保留：CuPy 与 Torch 各自通过全部 17 个 estimator case，requested/executed backend 一致且无 fallback；focused disconnected two-way FE artifact 也把 df=1 inference boundary 验证到机器精度。该运行中每个 backend 的 4 个 Hausman parameterization 都是正确的结构化 `applicable=false` case，因此它们验证了 applicability/reason parity，但没有在物理 GPU 上执行 applicable Hausman 的 statistic/p-value/df 路径。", + "- 已将 exact-head raw artifact `results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json`": "- Ready-for-review 审计因此重新打开 physical gate。当前 runner 新增一个确定性的 48-observation、one-slope、nonzero-entity-effect fitted FE/RE fixture；它在 hosted NumPy reference 上稳定为 Hausman applicable，并要求每个 CuPy/Torch 物理 backend 对 FE/RE coefficient、diagnostic covariance、Hausman statistic、p-value 和 df 与 NumPy 做一致性验证。历史 `panel_stage_b_pr122_p100_20260809.json` 继续作为此前运行的不可变 42-row 记录；PR #122 的最终接受现在要求新的 exact-head P100 run，随后生成新的 44-row canonical source 并刷新 frontend assets。当前 hard exit：`PARTIAL_REMOTE_PENDING`。", + }, + } + + for filename, replacements in updates.items(): + path = Path(filename) + lines = path.read_text(encoding="utf-8").splitlines() + used = {key: False for key in replacements} + out = [] + for line in lines: + replaced = False + for prefix, new_line in replacements.items(): + if line.startswith(prefix): + out.append(new_line) + used[prefix] = True + replaced = True + break + if not replaced: + out.append(line) + missing = [key for key, seen in used.items() if not seen] + if missing: + raise RuntimeError(f"{filename}: replacement anchors not found: {missing}") + path.write_text("\n".join(out) + "\n", encoding="utf-8") + PY + - name: Validate changelog diff + run: | + git diff --check + git diff -- docs/en/changelog.md docs/cn/changelog.md + - name: Commit changelog sync and remove temporary workflows + run: | + rm .github/workflows/pr122-sync-pending-changelog.yml + rm .github/workflows/pr122-sync-pending-changelog-v2.yml + rm .github/workflows/pr122-sync-pending-changelog-v3.yml + git diff --check + git config user.name 'github-actions[bot]' + git config user.email '41898282+github-actions[bot]@users.noreply.github.com' + git add -A + git commit -m 'docs: mark PR122 applicable Hausman physical gate pending' + git push origin HEAD:agent/panel-p1-stage-b-diagnostics From 48184a2c965b003d071809562627b09ac02345e7 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Sun, 9 Aug 2026 10:56:34 +0000 Subject: [PATCH 150/165] docs: mark PR122 applicable Hausman physical gate pending --- .../pr122-sync-pending-changelog-v2.yml | 39 ---------- .../pr122-sync-pending-changelog-v3.yml | 77 ------------------- .../pr122-sync-pending-changelog.yml | 38 --------- docs/cn/changelog.md | 8 +- docs/en/changelog.md | 8 +- 5 files changed, 8 insertions(+), 162 deletions(-) delete mode 100644 .github/workflows/pr122-sync-pending-changelog-v2.yml delete mode 100644 .github/workflows/pr122-sync-pending-changelog-v3.yml delete mode 100644 .github/workflows/pr122-sync-pending-changelog.yml diff --git a/.github/workflows/pr122-sync-pending-changelog-v2.yml b/.github/workflows/pr122-sync-pending-changelog-v2.yml deleted file mode 100644 index 3cb12f284..000000000 --- a/.github/workflows/pr122-sync-pending-changelog-v2.yml +++ /dev/null @@ -1,39 +0,0 @@ -name: PR122 Pending Changelog Sync V2 - -on: - push: - branches: - - agent/panel-p1-stage-b-diagnostics - paths: - - .github/workflows/pr122-sync-pending-changelog-v2.yml - -permissions: - contents: write - -jobs: - sync: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v4 - with: - ref: agent/panel-p1-stage-b-diagnostics - fetch-depth: 0 - - uses: actions/setup-python@v5 - with: - python-version: '3.11' - - name: Update EN/CN changelog status - run: python -c "import base64; exec(base64.b64decode('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 ...TRUNCATED_FOR_DISPLAY... '))" - - name: Validate changelog diff - run: | - git diff --check - git diff -- docs/en/changelog.md docs/cn/changelog.md - - name: Commit changelog sync and remove temporary workflows - run: | - rm .github/workflows/pr122-sync-pending-changelog.yml - rm .github/workflows/pr122-sync-pending-changelog-v2.yml - git diff --check - git config user.name 'github-actions[bot]' - git config user.email '41898282+github-actions[bot]@users.noreply.github.com' - git add -A - git commit -m 'docs: mark PR122 applicable Hausman physical gate pending' - git push origin HEAD:agent/panel-p1-stage-b-diagnostics diff --git a/.github/workflows/pr122-sync-pending-changelog-v3.yml b/.github/workflows/pr122-sync-pending-changelog-v3.yml deleted file mode 100644 index 44029329c..000000000 --- a/.github/workflows/pr122-sync-pending-changelog-v3.yml +++ /dev/null @@ -1,77 +0,0 @@ -name: PR122 Pending Changelog Sync V3 - -on: - push: - branches: - - agent/panel-p1-stage-b-diagnostics - paths: - - .github/workflows/pr122-sync-pending-changelog-v3.yml - -permissions: - contents: write - -jobs: - sync: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v4 - with: - ref: agent/panel-p1-stage-b-diagnostics - fetch-depth: 0 - - uses: actions/setup-python@v5 - with: - python-version: '3.11' - - name: Update EN/CN changelog status - shell: bash - run: | - python - <<'PY' - from pathlib import Path - - updates = { - "docs/en/changelog.md": { - "> Last updated: 2026-08-08
": "> Last updated: 2026-08-09
", - "- Added `dev/benchmarks/validate_panel_stage_b_gpu.py` as the exact-head physical correctness/provenance gate.": "- Added `dev/benchmarks/validate_panel_stage_b_gpu.py` as the exact-head physical correctness/provenance gate. The previously accepted P100 artifacts at numerical implementation `a57efcea29b0e87ecb89865c5a6902d5773812c6` remain immutable historical evidence: CuPy and Torch each passed all 17 estimator cases with requested-backend provenance and no fallback, while the focused disconnected two-way FE artifact validated the df=1 inference boundary to machine precision. The four Hausman parameterizations per backend in that run were all correctly structured `applicable=false` cases, so they validate applicability/reason parity but do not physically exercise an applicable Hausman statistic/p-value/df path.", - "- Promoted the exact-head raw artifact `results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json`": "- A Ready-for-review audit reopened the physical gate for that coverage gap. The current runner adds a deterministic 48-observation, one-slope, nonzero-entity-effect fitted FE/RE fixture that is stably Hausman-applicable on the hosted NumPy reference and requires each CuPy/Torch physical backend to match FE/RE coefficients, diagnostic covariance, Hausman statistic, p-value, and df. The historical `panel_stage_b_pr122_p100_20260809.json` remains an immutable 42-row record of the earlier run; final PR #122 acceptance now requires a fresh exact-head P100 run followed by a new 44-row canonical source and regenerated frontend assets. Current hard exit: `PARTIAL_REMOTE_PENDING`.", - }, - "docs/cn/changelog.md": { - "> 最后更新：2026-08-08
": "> 最后更新：2026-08-09
", - "- 新增 `dev/benchmarks/validate_panel_stage_b_gpu.py` 作为 exact-head physical correctness/provenance gate。": "- 新增 `dev/benchmarks/validate_panel_stage_b_gpu.py` 作为 exact-head physical correctness/provenance gate。此前在数值实现 `a57efcea29b0e87ecb89865c5a6902d5773812c6` 上接受的 P100 artifact 继续作为不可变的历史证据保留：CuPy 与 Torch 各自通过全部 17 个 estimator case，requested/executed backend 一致且无 fallback；focused disconnected two-way FE artifact 也把 df=1 inference boundary 验证到机器精度。该运行中每个 backend 的 4 个 Hausman parameterization 都是正确的结构化 `applicable=false` case，因此它们验证了 applicability/reason parity，但没有在物理 GPU 上执行 applicable Hausman 的 statistic/p-value/df 路径。", - "- 已将 exact-head raw artifact `results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json`": "- Ready-for-review 审计因此重新打开 physical gate。当前 runner 新增一个确定性的 48-observation、one-slope、nonzero-entity-effect fitted FE/RE fixture；它在 hosted NumPy reference 上稳定为 Hausman applicable，并要求每个 CuPy/Torch 物理 backend 对 FE/RE coefficient、diagnostic covariance、Hausman statistic、p-value 和 df 与 NumPy 做一致性验证。历史 `panel_stage_b_pr122_p100_20260809.json` 继续作为此前运行的不可变 42-row 记录；PR #122 的最终接受现在要求新的 exact-head P100 run，随后生成新的 44-row canonical source 并刷新 frontend assets。当前 hard exit：`PARTIAL_REMOTE_PENDING`。", - }, - } - - for filename, replacements in updates.items(): - path = Path(filename) - lines = path.read_text(encoding="utf-8").splitlines() - used = {key: False for key in replacements} - out = [] - for line in lines: - replaced = False - for prefix, new_line in replacements.items(): - if line.startswith(prefix): - out.append(new_line) - used[prefix] = True - replaced = True - break - if not replaced: - out.append(line) - missing = [key for key, seen in used.items() if not seen] - if missing: - raise RuntimeError(f"{filename}: replacement anchors not found: {missing}") - path.write_text("\n".join(out) + "\n", encoding="utf-8") - PY - - name: Validate changelog diff - run: | - git diff --check - git diff -- docs/en/changelog.md docs/cn/changelog.md - - name: Commit changelog sync and remove temporary workflows - run: | - rm .github/workflows/pr122-sync-pending-changelog.yml - rm .github/workflows/pr122-sync-pending-changelog-v2.yml - rm .github/workflows/pr122-sync-pending-changelog-v3.yml - git diff --check - git config user.name 'github-actions[bot]' - git config user.email '41898282+github-actions[bot]@users.noreply.github.com' - git add -A - git commit -m 'docs: mark PR122 applicable Hausman physical gate pending' - git push origin HEAD:agent/panel-p1-stage-b-diagnostics diff --git a/.github/workflows/pr122-sync-pending-changelog.yml b/.github/workflows/pr122-sync-pending-changelog.yml deleted file mode 100644 index 14598ccd8..000000000 --- a/.github/workflows/pr122-sync-pending-changelog.yml +++ /dev/null @@ -1,38 +0,0 @@ -name: PR122 Pending Changelog Sync - -on: - push: - branches: - - agent/panel-p1-stage-b-diagnostics - paths: - - .github/workflows/pr122-sync-pending-changelog.yml - -permissions: - contents: write - -jobs: - sync: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v4 - with: - ref: agent/panel-p1-stage-b-diagnostics - fetch-depth: 0 - - uses: actions/setup-python@v5 - with: - python-version: '3.11' - - name: Update EN/CN changelog status - run: python -c "import base64; exec(base64.b64decode('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 ... [payload truncated for display] ...'))" - - name: Validate changelog diff - run: | - git diff --check - git diff -- docs/en/changelog.md docs/cn/changelog.md - - name: Commit changelog sync and remove temporary workflow - run: | - rm .github/workflows/pr122-sync-pending-changelog.yml - git diff --check - git config user.name 'github-actions[bot]' - git config user.email '41898282+github-actions[bot]@users.noreply.github.com' - git add -A - git commit -m 'docs: mark PR122 applicable Hausman physical gate pending' - git push origin HEAD:agent/panel-p1-stage-b-diagnostics diff --git a/docs/cn/changelog.md b/docs/cn/changelog.md index 1d904c836..68c76ffe3 100644 --- a/docs/cn/changelog.md +++ b/docs/cn/changelog.md @@ -1,7 +1,7 @@ # Changelog > 语言：中文
-> 最后更新：2026-08-08
+> 最后更新：2026-08-09
> 页面定位：变更记录
> 切换：[English](../en/changelog.md) @@ -14,8 +14,8 @@ - 新增 fixed-effects classical pooling F、one-way entity error-components Breusch-Pagan LM（包含 Baltagi-Li unbalanced-panel 公式）以及 classical one-way entity FE-vs-RE Hausman。计量上不适用的情况返回结构化 reason；Hausman covariance difference 若为奇异 PSD，则使用明确记录的 generalized-inverse/rank extension；若实质 indefinite，则直接报告不可用。 - `PooledOLS.fit()` 与 `FamaMacBeth.fit()` 的可选 `entity_ids` 只用于 Stage-B within/between fit statistics 和 panel BP-LM。Pooled HAC 稳定排序现在让 entity diagnostic metadata 与 X/y 使用完全相同的 permutation；formula missing-row filtering 也会在形成 diagnostics 前对齐 observation-level side arrays。 - 增加 analytic/fitted regression、维护中的 Python 3.9 + Torch 2.0 CPU parity，以及可执行的 `linearmodels==7.0` definition-alignment job。FirstDifference 的外部比较只在两边 transformed sample 定义一致的 panel 上执行；Stage B 不会为了 external gate 静默改变 Stage-A 对内部缺期采用 adjacent-observed-row differencing 的既有契约。 -- 新增 `dev/benchmarks/validate_panel_stage_b_gpu.py` 作为 exact-head physical correctness/provenance gate。最终 schema-2 物理运行已在精确 clean implementation head `faa95ce7fb5cb204088957fbda5544c20a06fbfc` 上通过，环境为 Tesla P100-SXM2-16GB 与 Python 3.9.16：CuPy 与 Torch CUDA 各自通过全部 17 个 estimator case 和 4 个 Hausman diagnostic，无 CPU fallback。explicit-constant RandomEffects 相对 NumPy 的最大 coefficient difference 为 `2.22e-16`，所有 RandomEffects diagnostic contract 都与 NumPy 完全一致。raw metadata 报告 PyTorch 2.0.0；CuPy package-version lookup 为 `null`，因此不再沿用旧运行中的 CuPy 版本信息。 -- 已将 exact-head raw artifact `results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json`（SHA-256 `c1ba014a3b9bb0d32cbc0ca3d844ccfe767e7149189efb9ba2969f5bc1b94b31`）提升为受 SHA 保护的 canonical validation-only frontend source。dashboard 现在发布 42 条 Stage-B validation row：34 条 estimator/backend row 与 8 条 Hausman/backend row；不伪造 timing 或 speedup 字段，并区分 standard Hausman 与 RE-explicit-constant Hausman parameterization。 +- 新增 `dev/benchmarks/validate_panel_stage_b_gpu.py` 作为 exact-head physical correctness/provenance gate。此前在数值实现 `a57efcea29b0e87ecb89865c5a6902d5773812c6` 上接受的 P100 artifact 继续作为不可变的历史证据保留：CuPy 与 Torch 各自通过全部 17 个 estimator case，requested/executed backend 一致且无 fallback；focused disconnected two-way FE artifact 也把 df=1 inference boundary 验证到机器精度。该运行中每个 backend 的 4 个 Hausman parameterization 都是正确的结构化 `applicable=false` case，因此它们验证了 applicability/reason parity，但没有在物理 GPU 上执行 applicable Hausman 的 statistic/p-value/df 路径。 +- Ready-for-review 审计因此重新打开 physical gate。当前 runner 新增一个确定性的 48-observation、one-slope、nonzero-entity-effect fitted FE/RE fixture；它在 hosted NumPy reference 上稳定为 Hausman applicable，并要求每个 CuPy/Torch 物理 backend 对 FE/RE coefficient、diagnostic covariance、Hausman statistic、p-value 和 df 与 NumPy 做一致性验证。历史 `panel_stage_b_pr122_p100_20260809.json` 继续作为此前运行的不可变 42-row 记录；PR #122 的最终接受现在要求新的 exact-head P100 run，随后生成新的 44-row canonical source 并刷新 frontend assets。当前 hard exit：`PARTIAL_REMOTE_PENDING`。 关联：Issue #93 与 pull request #122。 @@ -145,4 +145,4 @@ Stage B diagnostics 与 Stage C covariance 扩展继续由 Issue #93 跟踪；St ## 更早的历史记录 截至 2026-08-03 的详细条目保留在 -[归档 changelog](changelog-history-through-2026-08-03.markdown)。 \ No newline at end of file +[归档 changelog](changelog-history-through-2026-08-03.markdown)。 diff --git a/docs/en/changelog.md b/docs/en/changelog.md index 9e1553091..94842900d 100644 --- a/docs/en/changelog.md +++ b/docs/en/changelog.md @@ -1,7 +1,7 @@ # Changelog > Language: English
-> Last updated: 2026-08-08
+> Last updated: 2026-08-09
> This page: Changelog
> Switch: [Chinese](../cn/changelog.md) @@ -14,8 +14,8 @@ - Added the classical pooling F test for fixed effects, the one-way entity error-components Breusch-Pagan LM test including the Baltagi-Li unbalanced-panel formula, and the classical one-way entity FE-vs-RE Hausman test. Inapplicable econometric cases return structured reasons; singular positive-semidefinite Hausman covariance differences use a documented generalized-inverse/rank extension, while materially indefinite differences are rejected. - Added optional `entity_ids` to `PooledOLS.fit()` and `FamaMacBeth.fit()` solely for Stage-B within/between fit statistics and the panel BP-LM path. Pooled HAC sorting now carries entity diagnostic metadata through the same stable permutation as X/y. Formula missing-row filtering aligns observation-level side arrays before diagnostics are formed. - Added analytic/fitted regressions, maintained Python 3.9 + Torch 2.0 CPU parity, and an executable `linearmodels==7.0` definition-alignment job. FirstDifference external comparison is restricted to panels where both implementations use the same transformed sample; Stage B does not silently redefine the Stage-A adjacent-observed-row differencing contract for internal time gaps. -- Added `dev/benchmarks/validate_panel_stage_b_gpu.py` as the exact-head physical correctness/provenance gate. The final schema-2 run passed on clean implementation head `faa95ce7fb5cb204088957fbda5544c20a06fbfc` using Tesla P100-SXM2-16GB and Python 3.9.16: CuPy and Torch CUDA each passed all 17 estimator cases and all four Hausman diagnostics with no CPU fallback. The largest explicit-constant RandomEffects coefficient difference from NumPy was `2.22e-16`, and the RandomEffects diagnostic contract matched NumPy exactly. The raw metadata reports PyTorch 2.0.0; its CuPy package-version lookup is unavailable (`null`), so no CuPy version is inferred from an earlier run. -- Promoted the exact-head raw artifact `results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json` (SHA-256 `c1ba014a3b9bb0d32cbc0ca3d844ccfe767e7149189efb9ba2969f5bc1b94b31`) into the SHA-protected canonical validation-only frontend source. The dashboard now publishes 42 Stage-B validation rows—34 estimator/backend rows plus eight Hausman/backend rows—without fabricating timing or speedup fields, and distinguishes the standard versus RE-explicit-constant Hausman parameterizations. +- Added `dev/benchmarks/validate_panel_stage_b_gpu.py` as the exact-head physical correctness/provenance gate. The previously accepted P100 artifacts at numerical implementation `a57efcea29b0e87ecb89865c5a6902d5773812c6` remain immutable historical evidence: CuPy and Torch each passed all 17 estimator cases with requested-backend provenance and no fallback, while the focused disconnected two-way FE artifact validated the df=1 inference boundary to machine precision. The four Hausman parameterizations per backend in that run were all correctly structured `applicable=false` cases, so they validate applicability/reason parity but do not physically exercise an applicable Hausman statistic/p-value/df path. +- A Ready-for-review audit reopened the physical gate for that coverage gap. The current runner adds a deterministic 48-observation, one-slope, nonzero-entity-effect fitted FE/RE fixture that is stably Hausman-applicable on the hosted NumPy reference and requires each CuPy/Torch physical backend to match FE/RE coefficients, diagnostic covariance, Hausman statistic, p-value, and df. The historical `panel_stage_b_pr122_p100_20260809.json` remains an immutable 42-row record of the earlier run; final PR #122 acceptance now requires a fresh exact-head P100 run followed by a new 44-row canonical source and regenerated frontend assets. Current hard exit: `PARTIAL_REMOTE_PENDING`. Related: Issue #93 and pull request #122. @@ -148,4 +148,4 @@ Related: Issue #45, Issue #81, Issue #82, Issue #83, and pull request #87. ## Earlier history Detailed entries through 2026-08-03 are retained in -[the archived changelog](changelog-history-through-2026-08-03.markdown). \ No newline at end of file +[the archived changelog](changelog-history-through-2026-08-03.markdown). From 0e6da46ee406082e1dff3576f778446828c5c3b0 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 19:02:38 +0800 Subject: [PATCH 151/165] docs: record PR122 local review-fix closure --- dev/reviews/pr122_physical_gpu_validation.md | 21 ++++++++++++++++++-- 1 file changed, 19 insertions(+), 2 deletions(-) diff --git a/dev/reviews/pr122_physical_gpu_validation.md b/dev/reviews/pr122_physical_gpu_validation.md index d5bac18e3..9bbc377f4 100644 --- a/dev/reviews/pr122_physical_gpu_validation.md +++ b/dev/reviews/pr122_physical_gpu_validation.md @@ -97,6 +97,23 @@ The currently committed canonical source remains the historical `a57efcea...` me It remains an immutable description of that historical physical run, but it must not be treated as final acceptance for the current runner. After the new exact-clean-head P100 run succeeds, a new canonical source must replace it and the frontend generated assets/contracts must be regenerated. With the new applicable Hausman diagnostic, the expected Stage-B validation row count is 44: 17 estimator cases x 2 backends plus 5 Hausman diagnostics x 2 backends. +The PR122 evidence promotion step is an explicit source-registration action rather than a separate automatic normalizer. The current parser contract therefore requires the future canonical source to preserve the dedicated applicable Hausman `statistic`, `pvalue`, and `df`; if any are missing or invalid, the emitted validation row fails closed instead of publishing a passing result. + +## Local review/fix closure + +The review/fix cycle was re-run against the changed and adjacent files under `.claude/skills/code-review.md`. Local fixes now cover: + +- a deterministic, nonzero-entity-effect, fitted Hausman-applicable physical fixture; +- per-backend fail-closed enforcement requiring a successful applicable Hausman statistic/p-value/df result; +- FE/RE coefficient and diagnostic-covariance comparison for the dedicated physical fixture; +- hosted physical-runner regression coverage under the Python 3.9 / NumPy 1.24.2 / SciPy 1.10.1 stack; +- a dedicated 48 x 1 frontend identity and method/variant separation for the new fixture; +- canonical numeric-evidence fail-closed parsing for statistic/pvalue/df; +- explicit execution of the new parser regression in the maintained Benchmark Frontend Python 3.9/3.11 matrix; +- EN/CN changelog synchronization marking the older 42-row source as historical rather than final acceptance. + +No further locally actionable CRITICAL, HIGH, or in-scope MEDIUM finding was identified in the final changed+adjacent review. Exact-head hosted CI must still pass before this local closure is treated as complete. + ## Required remote closure Final physical acceptance now requires a fresh exact-clean-head P100 execution of `dev/benchmarks/validate_panel_stage_b_gpu.py` on the final runner head, with both CuPy and Torch requested. @@ -114,7 +131,7 @@ The new artifact must demonstrate, for each backend: After that run is accepted, the lifecycle must: - commit the immutable raw result; -- promote a new canonical Stage-B source; +- promote a new canonical Stage-B source preserving statistic/pvalue/df for the dedicated applicable Hausman fixture; - update source/coverage contracts for five Hausman diagnostics per backend and 44 validation rows; - regenerate the six tracked frontend/docs JSON assets; - rerun exact-final-head hosted CI; @@ -123,7 +140,7 @@ After that run is accepted, the lifecycle must: ## Hard-exit conclusion -Local fix status: the current review finding is fixed in runner/test code and targeted local/hosted checks pass. +Local fix status: the current review finding and all locally discovered adjacent coverage/documentation findings are fixed in runner/test/parser/CI/docs code. Targeted local/hosted checks passed before the closure commit; exact-head full hosted CI remains required. Remote status: a fresh P100 CuPy/Torch artifact is required because the physical validation runner changed. From 773beec4e412e69f910add141ade7bef0fad14f7 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 19:05:58 +0800 Subject: [PATCH 152/165] docs: clarify physical evidence invalidation rule --- RELEASING.md | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/RELEASING.md b/RELEASING.md index dd9397aa1..e4f08882b 100644 --- a/RELEASING.md +++ b/RELEASING.md @@ -80,6 +80,15 @@ contracts, documentation contracts, and the Python 3.9–3.12 regression matrix. For changes affecting CuPy, Torch, inference, device routing, or performance, record physical-GPU acceptance on the exact release source commit. +Physical evidence is tied to both the numerical implementation and the validator +that defines the acceptance matrix. If a physical-validation runner changes after +an artifact has been accepted—for example, because review adds a previously +uncovered inference branch—the old artifact remains useful historical evidence +but no longer proves the new acceptance contract. Return the affected pull +request to a pending/draft state, rerun the changed validator on an exact clean +candidate head, and only then promote new canonical evidence or restore a +Ready/merge-ready conclusion. + ### Package validation The `Release package validation` workflow automatically: From 2701aa9feb3796c33c94e6480fcb78c80c6a809c Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 19:06:14 +0800 Subject: [PATCH 153/165] test: lock applicable Hausman case identity --- dev/tests/test_panel_stage_b_applicable_hausman_parser.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/dev/tests/test_panel_stage_b_applicable_hausman_parser.py b/dev/tests/test_panel_stage_b_applicable_hausman_parser.py index 096754265..ade408f60 100644 --- a/dev/tests/test_panel_stage_b_applicable_hausman_parser.py +++ b/dev/tests/test_panel_stage_b_applicable_hausman_parser.py @@ -85,6 +85,9 @@ def test_parser_distinguishes_dedicated_applicable_hausman_fixture(tmp_path) -> dedicated_methods = {run["method_config_id"] for run in dedicated} standard_methods = {run["method_config_id"] for run in standard_balanced} assert dedicated_methods.isdisjoint(standard_methods) + dedicated_cases = {run["case_id"] for run in dedicated} + standard_cases = {run["case_id"] for run in standard_balanced} + assert dedicated_cases.isdisjoint(standard_cases) def test_parser_fails_closed_when_applicable_numeric_evidence_is_missing(tmp_path) -> None: From 0d0d654d825cea872672f27d02107a58048b345f Mon Sep 17 00:00:00 2001 From: TheHiddenObserver Date: Sun, 9 Aug 2026 22:20:03 +0800 Subject: [PATCH 154/165] benchmark: record PR122 P100 Stage B validation 2701aa9f --- ...panel_stage_b_gpu_validation_2701aa9f.json | 896 ++++++++++++++++++ 1 file changed, 896 insertions(+) create mode 100644 results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json diff --git a/results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json b/results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json new file mode 100644 index 000000000..fa3a253e6 --- /dev/null +++ b/results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json @@ -0,0 +1,896 @@ +{ + "schema_version": 2, + "generated_at": "2026-08-09T14:06:57.406080Z", + "git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", + "working_tree_clean": true, + "status": "success", + "environment": { + "python": "3.9.16", + "platform": "Linux-3.10.0-1062.el7.x86_64-x86_64-with-glibc2.31", + "gpu": "Tesla P100-SXM2-16GB", + "packages": { + "statgpu": "0.2.4", + "numpy": "1.24.2", + "scipy": "1.10.1", + "cupy": null, + "torch": "2.0.0" + } + }, + "tolerances": { + "rtol": 5e-06, + "atol": 5e-07 + }, + "datasets": { + "balanced": { + "nobs": 54 + }, + "unbalanced": { + "nobs": 49 + }, + "hausman_applicable_nonzero_effect": { + "nobs": 48, + "seed": 20260810, + "n_entities": 12, + "n_times": 4, + "entity_effect_scale": 0.005, + "noise_scale": 0.1, + "reference_variance_difference": 4.6413153162319366e-05 + } + }, + "backends": { + "cupy": { + "models": { + "pooled_balanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 5.551115123125783e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 7.105427357601002e-15, + "pvalues": 4.440892098500626e-15, + "conf_int": 6.661338147750939e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 1.1102230246251565e-16, + "fit_statistics.rsquared_between": 7.771561172376096e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 1.4210854715202004e-14, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 1.734723475976807e-18, + "bp_lm.statistic": 1.4210854715202004e-13, + "bp_lm.pvalue": 1.0908587575630828e-35 + } + }, + "pooled_hac_unsorted_balanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 5.551115123125783e-16, + "bse": 2.7755575615628914e-17, + "tvalues": 1.0658141036401503e-14, + "pvalues": 1.1964340379966992e-20, + "conf_int": 6.661338147750939e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 2.220446049250313e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 1.4210854715202004e-14, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 3.469446951953614e-18, + "bp_lm.statistic": 7.105427357601002e-14, + "bp_lm.pvalue": 4.8430367253878245e-36 + } + }, + "between_balanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 5.551115123125783e-17, + "bse": 5.551115123125783e-17, + "tvalues": 4.440892098500626e-16, + "pvalues": 2.7755575615628914e-16, + "conf_int": 1.6653345369377348e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 0.0, + "fit_statistics.rsquared_overall": 3.3306690738754696e-16, + "fit_statistics.rsquared_adj": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 0.0, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 2.7755575615628914e-17 + } + }, + "first_difference_balanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 6.938893903907228e-18, + "tvalues": 0.0, + "pvalues": 1.9665546849844295e-156, + "conf_int": 1.1102230246251565e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 5.684341886080801e-13, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 4.336808689942018e-19 + } + }, + "panel_entity_balanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 0.0, + "bse": 6.938893903907228e-18, + "tvalues": 7.105427357601002e-15, + "pvalues": 0.0, + "conf_int": 1.1102230246251565e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 2.220446049250313e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 1.1368683772161603e-13, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 4.336808689942018e-19, + "pooling_f.statistic": 2.1316282072803006e-14, + "pooling_f.pvalue": 0.0 + } + }, + "random_effects_balanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 7.105427357601002e-15, + "pvalues": 0.0, + "conf_int": 1.1102230246251565e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 0.0, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 5.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 8.673617379884035e-19, + "random_effects_diagnostic_contract": 0.0 + } + }, + "random_effects_explicit_constant_balanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 9.71445146547012e-17, + "bse": 1.3877787807814457e-17, + "tvalues": 3.552713678800501e-15, + "pvalues": 4.440892098500626e-16, + "conf_int": 1.1102230246251565e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 0.0, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 0.0, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 1.734723475976807e-18, + "random_effects_diagnostic_contract": 0.0 + } + }, + "fama_macbeth_balanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 3.552713678800501e-15, + "pvalues": 5.421010862427522e-18, + "conf_int": 2.220446049250313e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 2.220446049250313e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 0.0, + "fit_statistics.f_pvalue": 0.0 + } + }, + "panel_two_way_balanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 4.440892098500626e-16, + "bse": 0.0, + "tvalues": 1.0658141036401503e-14, + "pvalues": 0.0, + "conf_int": 4.440892098500626e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 2.220446049250313e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 0.0, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 4.0657581468206416e-20, + "pooling_f.statistic": 0.0, + "pooling_f.pvalue": 0.0 + } + }, + "pooled_unbalanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 0.0, + "tvalues": 3.552713678800501e-15, + "pvalues": 1.9984014443252818e-15, + "conf_int": 2.220446049250313e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 0.0, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 1.4210854715202004e-14, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 1.0842021724855044e-19, + "bp_lm.statistic": 2.842170943040401e-14, + "bp_lm.pvalue": 1.7333369499485123e-33 + } + }, + "pooled_hac_unsorted_unbalanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 4.996003610813204e-16, + "bse": 2.7755575615628914e-17, + "tvalues": 5.995204332975845e-15, + "pvalues": 3.3306690738754696e-15, + "conf_int": 5.551115123125783e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 1.1102230246251565e-16, + "fit_statistics.rsquared_between": 2.220446049250313e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 2.842170943040401e-14, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 4.0115480381963664e-18, + "bp_lm.statistic": 0.0, + "bp_lm.pvalue": 0.0 + } + }, + "between_unbalanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 2.7755575615628914e-17, + "tvalues": 2.220446049250313e-16, + "pvalues": 1.1102230246251565e-16, + "conf_int": 4.440892098500626e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 1.1102230246251565e-16, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 2.220446049250313e-16, + "fit_statistics.f_statistic": 7.771561172376096e-16, + "fit_statistics.f_pvalue": 3.3306690738754696e-16, + "diagnostic_covariance": 5.551115123125783e-17 + } + }, + "first_difference_unbalanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 0.0, + "bse": 3.469446951953614e-18, + "tvalues": 7.105427357601002e-15, + "pvalues": 6.9283089726601085e-121, + "conf_int": 0.0, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 1.1368683772161603e-13, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 1.0842021724855044e-19 + } + }, + "panel_entity_unbalanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 6.938893903907228e-18, + "tvalues": 0.0, + "pvalues": 0.0, + "conf_int": 2.220446049250313e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 2.2737367544323206e-13, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 3.2526065174565133e-19, + "pooling_f.statistic": 7.105427357601002e-15, + "pooling_f.pvalue": 0.0 + } + }, + "random_effects_unbalanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 6.938893903907228e-18, + "tvalues": 5.329070518200751e-15, + "pvalues": 0.0, + "conf_int": 1.1102230246251565e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 2.2737367544323206e-13, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 2.168404344971009e-19, + "random_effects_diagnostic_contract": 0.0 + } + }, + "random_effects_explicit_constant_unbalanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 4.163336342344337e-17, + "bse": 1.3877787807814457e-17, + "tvalues": 7.105427357601002e-15, + "pvalues": 0.0, + "conf_int": 8.326672684688674e-17, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 2.220446049250313e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 5.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 3.469446951953614e-18, + "random_effects_diagnostic_contract": 0.0 + } + }, + "fama_macbeth_unbalanced": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 5.551115123125783e-17, + "tvalues": 5.329070518200751e-15, + "pvalues": 2.220446049250313e-16, + "conf_int": 4.440892098500626e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 1.1102230246251565e-16, + "fit_statistics.rsquared_between": 0.0, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 0.0, + "fit_statistics.f_pvalue": 0.0 + } + } + }, + "diagnostics": { + "hausman_balanced": { + "status": "success", + "max_abs_differences": { + "statistic": 0.0, + "pvalue": 0.0 + }, + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_explicit_re_constant_balanced": { + "status": "success", + "max_abs_differences": { + "statistic": 0.0, + "pvalue": 0.0 + }, + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_unbalanced": { + "status": "success", + "max_abs_differences": { + "statistic": 0.0, + "pvalue": 0.0 + }, + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_explicit_re_constant_unbalanced": { + "status": "success", + "max_abs_differences": { + "statistic": 0.0, + "pvalue": 0.0 + }, + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_applicable_nonzero_effect": { + "status": "success", + "max_abs_differences": { + "statistic": 7.260858581048524e-14, + "pvalue": 1.454392162258955e-14 + }, + "fit_max_abs_differences": { + "fe_coef": 0.0, + "re_coef": 2.220446049250313e-16, + "fe_covariance": 0.0, + "re_covariance": 5.421010862427522e-20 + }, + "applicable": true, + "reason": null, + "statistic": 1.1965942530851057, + "pvalue": 0.27400344142676447, + "df": 1.0, + "reference_statistic": 1.196594253085033, + "reference_pvalue": 0.274003441426779, + "reference_df": 1.0, + "reference_variance_difference": 4.6413153162319366e-05, + "fixture": { + "seed": 20260810, + "n_entities": 12, + "n_times": 4, + "entity_effect_scale": 0.005, + "noise_scale": 0.1 + } + } + } + }, + "torch": { + "models": { + "pooled_balanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 6.661338147750939e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 8.881784197001252e-15, + "pvalues": 1.1275609692606992e-06, + "conf_int": 1.6652982326448296e-09, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 2.220446049250313e-16, + "fit_statistics.rsquared_between": 8.881784197001252e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 1.4210854715202004e-14, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 1.734723475976807e-18, + "bp_lm.statistic": 2.4158453015843406e-13, + "bp_lm.pvalue": 1.9325127127518407e-35 + } + }, + "pooled_hac_unsorted_balanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 6.661338147750939e-16, + "bse": 2.7755575615628914e-17, + "tvalues": 1.0658141036401503e-14, + "pvalues": 1.7470054537119944e-20, + "conf_int": 6.661338147750939e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 1.1102230246251565e-16, + "fit_statistics.rsquared_between": 3.3306690738754696e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 1.4210854715202004e-14, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 3.903127820947816e-18, + "bp_lm.statistic": 1.7053025658242404e-13, + "bp_lm.pvalue": 1.3259576277275403e-35 + } + }, + "between_balanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 5.551115123125783e-17, + "bse": 1.1102230246251565e-16, + "tvalues": 6.661338147750939e-16, + "pvalues": 2.7755575615628914e-16, + "conf_int": 1.6653345369377348e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 2.220446049250313e-16, + "fit_statistics.rsquared_overall": 2.220446049250313e-16, + "fit_statistics.rsquared_adj": 3.3306690738754696e-16, + "fit_statistics.f_statistic": 1.7763568394002505e-15, + "fit_statistics.f_pvalue": 3.3306690738754696e-16, + "diagnostic_covariance": 5.551115123125783e-17 + } + }, + "first_difference_balanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 0.0, + "bse": 1.3877787807814457e-17, + "tvalues": 1.4210854715202004e-14, + "pvalues": 8.539945807941643e-156, + "conf_int": 5.551115123125783e-17, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 3.3306690738754696e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 3.410605131648481e-13, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 7.589415207398531e-19 + } + }, + "panel_entity_balanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 3.469446951953614e-18, + "tvalues": 3.552713678800501e-15, + "pvalues": 0.0, + "conf_int": 4.719586943480181e-10, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 3.3306690738754696e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 1.1368683772161603e-13, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 2.168404344971009e-19, + "pooling_f.statistic": 7.105427357601002e-15, + "pooling_f.pvalue": 0.0 + } + }, + "random_effects_balanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 0.0, + "tvalues": 3.552713678800501e-15, + "pvalues": 0.0, + "conf_int": 6.353757520116687e-10, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 0.0, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 0.0, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 2.168404344971009e-19, + "random_effects_diagnostic_contract": 0.0 + } + }, + "random_effects_explicit_constant_balanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 1.3877787807814457e-16, + "bse": 0.0, + "tvalues": 1.3322676295501878e-15, + "pvalues": 2.841572954714877e-08, + "conf_int": 1.8457834705110088e-09, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 2.220446049250313e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 5.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 2.168404344971009e-19, + "random_effects_diagnostic_contract": 0.0 + } + }, + "fama_macbeth_balanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 5.551115123125783e-17, + "bse": 1.3877787807814457e-17, + "tvalues": 1.7763568394002505e-15, + "pvalues": 3.2526065174565133e-18, + "conf_int": 1.1102230246251565e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 0.0, + "fit_statistics.rsquared_overall": 2.220446049250313e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 0.0, + "fit_statistics.f_pvalue": 0.0 + } + }, + "panel_two_way_balanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 3.3306690738754696e-16, + "bse": 0.0, + "tvalues": 7.105427357601002e-15, + "pvalues": 0.0, + "conf_int": 4.125351171779812e-10, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 3.3306690738754696e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 0.0, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 4.0657581468206416e-20, + "pooling_f.statistic": 7.105427357601002e-15, + "pooling_f.pvalue": 0.0 + } + }, + "pooled_unbalanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 4.0245584642661925e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 5.329070518200751e-15, + "pvalues": 6.327377473080986e-07, + "conf_int": 1.3248322994208195e-09, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 0.0, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 1.734723475976807e-18, + "bp_lm.statistic": 9.947598300641403e-14, + "bp_lm.pvalue": 6.0426052005149525e-33 + } + }, + "pooled_hac_unsorted_unbalanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 6.106226635438361e-16, + "bse": 2.7755575615628914e-17, + "tvalues": 9.2148511043888e-15, + "pvalues": 4.9960036108132044e-15, + "conf_int": 6.38378239159465e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 1.1102230246251565e-16, + "fit_statistics.rsquared_between": 2.220446049250313e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 2.842170943040401e-14, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 5.366800753803247e-18, + "bp_lm.statistic": 2.842170943040401e-14, + "bp_lm.pvalue": 1.7333369499485123e-33 + } + }, + "between_unbalanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 0.0, + "tvalues": 2.220446049250313e-16, + "pvalues": 1.1102230246251565e-16, + "conf_int": 4.440892098500626e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 2.220446049250313e-16, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 4.440892098500626e-16, + "fit_statistics.f_statistic": 1.4432899320127035e-15, + "fit_statistics.f_pvalue": 5.551115123125783e-16, + "diagnostic_covariance": 6.938893903907228e-17 + } + }, + "first_difference_unbalanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 0.0, + "bse": 6.938893903907228e-18, + "tvalues": 2.1316282072803006e-14, + "pvalues": 6.9283089726601085e-121, + "conf_int": 0.0, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 0.0, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 1.1368683772161603e-13, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 2.710505431213761e-19 + } + }, + "panel_entity_unbalanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 3.469446951953614e-18, + "tvalues": 1.4210854715202004e-14, + "pvalues": 0.0, + "conf_int": 2.8987834355120867e-10, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 2.220446049250313e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 3.410605131648481e-13, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 2.168404344971009e-19, + "pooling_f.statistic": 7.105427357601002e-15, + "pooling_f.pvalue": 0.0 + } + }, + "random_effects_unbalanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 0.0, + "tvalues": 3.552713678800501e-15, + "pvalues": 0.0, + "conf_int": 5.262852376120009e-10, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 0.0, + "fit_statistics.rsquared_overall": 0.0, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 0.0, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 0.0, + "random_effects_diagnostic_contract": 0.0 + } + }, + "random_effects_explicit_constant_unbalanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 1.4210854715202004e-14, + "pvalues": 2.1985840481519858e-08, + "conf_int": 1.818750788862289e-09, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 3.3306690738754696e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 1.1368683772161603e-13, + "fit_statistics.f_pvalue": 0.0, + "diagnostic_covariance": 1.734723475976807e-18, + "random_effects_diagnostic_contract": 0.0 + } + }, + "fama_macbeth_unbalanced": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 4.440892098500626e-16, + "bse": 8.326672684688674e-17, + "tvalues": 5.329070518200751e-15, + "pvalues": 1.6263032587282567e-19, + "conf_int": 6.661338147750939e-16, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 1.1102230246251565e-16, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 2.220446049250313e-16, + "fit_statistics.rsquared_adj": 0.0, + "fit_statistics.f_statistic": 0.0, + "fit_statistics.f_pvalue": 0.0 + } + } + }, + "diagnostics": { + "hausman_balanced": { + "status": "success", + "max_abs_differences": { + "statistic": 0.0, + "pvalue": 0.0 + }, + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_explicit_re_constant_balanced": { + "status": "success", + "max_abs_differences": { + "statistic": 0.0, + "pvalue": 0.0 + }, + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_unbalanced": { + "status": "success", + "max_abs_differences": { + "statistic": 0.0, + "pvalue": 0.0 + }, + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_explicit_re_constant_unbalanced": { + "status": "success", + "max_abs_differences": { + "statistic": 0.0, + "pvalue": 0.0 + }, + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_applicable_nonzero_effect": { + "status": "success", + "max_abs_differences": { + "statistic": 1.092459456231154e-13, + "pvalue": 2.1871393585115584e-14 + }, + "fit_max_abs_differences": { + "fe_coef": 0.0, + "re_coef": 3.3306690738754696e-16, + "fe_covariance": 0.0, + "re_covariance": 8.131516293641283e-20 + }, + "applicable": true, + "reason": null, + "statistic": 1.1965942530849238, + "pvalue": 0.2740034414268009, + "df": 1.0, + "reference_statistic": 1.196594253085033, + "reference_pvalue": 0.274003441426779, + "reference_df": 1.0, + "reference_variance_difference": 4.6413153162319366e-05, + "fixture": { + "seed": 20260810, + "n_entities": 12, + "n_times": 4, + "entity_effect_scale": 0.005, + "noise_scale": 0.1 + } + } + } + } + } +} From ad4a6606db9276d386fe25e38a9e77b845242a20 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 22:29:18 +0800 Subject: [PATCH 155/165] ci: finalize PR122 physical evidence once --- .github/workflows/pr122-finalize-evidence.yml | 389 ++++++++++++++++++ 1 file changed, 389 insertions(+) create mode 100644 .github/workflows/pr122-finalize-evidence.yml diff --git a/.github/workflows/pr122-finalize-evidence.yml b/.github/workflows/pr122-finalize-evidence.yml new file mode 100644 index 000000000..13a93048d --- /dev/null +++ b/.github/workflows/pr122-finalize-evidence.yml @@ -0,0 +1,389 @@ +name: PR122 finalize physical evidence + +on: + push: + branches: [agent/panel-p1-stage-b-diagnostics] + paths: + - '.github/workflows/pr122-finalize-evidence.yml' + +permissions: + contents: write + +jobs: + finalize: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + fetch-depth: 0 + - uses: actions/setup-python@v5 + with: + python-version: '3.11' + - name: Install Python validation dependencies + run: python -m pip install -U pip pytest 'jsonschema[format]' + - name: Promote exact-head P100 evidence and contracts + run: | + python - <<'PY' + from __future__ import annotations + + import json + import math + import re + import subprocess + from copy import deepcopy + from pathlib import Path + + root = Path.cwd() + measurement_sha = '2701aa9feb3796c33c94e6480fcb78c80c6a809c' + artifact_commit = '0d0d654d825cea872672f27d02107a58048b345f' + historical_measurement_sha = 'a57efcea29b0e87ecb89865c5a6902d5773812c6' + historical_artifact_commit = '72b3279d2028e8ec2af30e138e123aceb611ae8c' + + raw_rel = 'results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json' + focused_rel = 'results/pr122_p100/panel_stage_b_disconnected_fe_gpu_validation_a57efcea.json' + old_source_rel = 'results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809.json' + new_source_rel = 'results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809_2701aa9f.json' + raw_path = root / raw_rel + focused_path = root / focused_rel + old_source_path = root / old_source_rel + new_source_path = root / new_source_rel + + raw = json.loads(raw_path.read_text(encoding='utf-8')) + focused = json.loads(focused_path.read_text(encoding='utf-8')) + old = json.loads(old_source_path.read_text(encoding='utf-8')) + + assert raw['schema_version'] == 2 + assert raw['git_sha'] == measurement_sha + assert raw['working_tree_clean'] is True + assert raw['status'] == 'success' + assert raw['environment']['gpu'] == 'Tesla P100-SXM2-16GB' + assert raw['environment']['python'] == '3.9.16' + assert raw['environment']['packages']['numpy'] == '1.24.2' + assert raw['environment']['packages']['scipy'] == '1.10.1' + assert raw['environment']['packages']['torch'] == '2.0.0' + + expected_diagnostics = { + 'hausman_balanced', + 'hausman_explicit_re_constant_balanced', + 'hausman_unbalanced', + 'hausman_explicit_re_constant_unbalanced', + 'hausman_applicable_nonzero_effect', + } + for backend in ('cupy', 'torch'): + backend_raw = raw['backends'][backend] + models = backend_raw['models'] + assert len(models) == 17 + assert all(case['status'] == 'success' for case in models.values()) + assert all(case['executed_backend'] == backend for case in models.values()) + diagnostics = backend_raw['diagnostics'] + assert set(diagnostics) == expected_diagnostics + for diagnostic_id in expected_diagnostics - {'hausman_applicable_nonzero_effect'}: + diagnostic = diagnostics[diagnostic_id] + assert diagnostic['status'] == 'success' + assert diagnostic['applicable'] is False + assert diagnostic['reason'] == 'covariance difference is not positive semidefinite' + applicable = diagnostics['hausman_applicable_nonzero_effect'] + assert applicable['status'] == 'success' + assert applicable['applicable'] is True + assert applicable['reason'] is None + assert math.isfinite(float(applicable['statistic'])) + assert math.isfinite(float(applicable['pvalue'])) + assert float(applicable['df']) == 1.0 + assert float(applicable['max_abs_differences']['statistic']) < 2e-13 + assert float(applicable['max_abs_differences']['pvalue']) < 5e-14 + assert max(float(v) for v in applicable['fit_max_abs_differences'].values()) < 1e-12 + assert float(applicable['reference_variance_difference']) > 1e-6 + + raw_blob = subprocess.check_output(['git', 'hash-object', raw_rel], text=True).strip() + focused_blob = subprocess.check_output(['git', 'hash-object', focused_rel], text=True).strip() + assert raw_blob == 'fa3a253e6d882a4e69be29e7e3b1dce7b223b9a9' + assert focused_blob == '3bda0b2040479ba8201e2722eb990ba086c3f3b9' + assert focused['git_sha'] == historical_measurement_sha + assert focused['working_tree_clean'] is True + assert focused['status'] == 'success' + + promoted = deepcopy(old) + promoted['source_date'] = '2026-08-09' + promoted['git_sha'] = measurement_sha + promoted['working_tree_clean'] = True + promoted['status'] = 'success' + promoted['schema_status'] = 'ok' + promoted['raw_artifact'] = { + 'path': raw_rel, + 'repository_commit': artifact_commit, + 'git_blob_sha': raw_blob, + 'generated_at': raw['generated_at'], + 'schema_version': raw['schema_version'], + } + promoted['focused_artifact'] = { + 'path': focused_rel, + 'repository_commit': historical_artifact_commit, + 'git_blob_sha': focused_blob, + 'generated_at': focused.get('generated_at'), + 'schema_version': focused['schema_version'], + 'validation': 'panel_stage_b_disconnected_two_way_fe', + 'status': focused['status'], + 'measurement_git_sha': historical_measurement_sha, + 'role': 'historical supplementary evidence for unchanged disconnected-FE numerical path', + } + promoted['environment']['gpu'] = raw['environment']['gpu'] + promoted['environment']['platform'] = raw['environment']['platform'] + promoted['environment']['python'] = raw['environment']['python'] + promoted['environment']['packages'] = deepcopy(raw['environment']['packages']) + promoted['protocol']['runner_schema_version'] = raw['schema_version'] + promoted['protocol']['rtol'] = raw['tolerances']['rtol'] + promoted['protocol']['atol'] = raw['tolerances']['atol'] + promoted['backend_precision'] = {'cupy': 'pass', 'torch': 'pass'} + for backend in ('cupy', 'torch'): + promoted['compatibility_matrix'][backend]['model_cases'] = '17/17' + promoted['compatibility_matrix'][backend]['diagnostics'] = '5/5' + promoted['compatibility_matrix'][backend]['executed_backend'] = backend + promoted['compatibility_matrix'][backend]['cpu_fallback'] = False + promoted['compatibility_matrix'][backend]['disconnected_fe'] = 'pass' + promoted['inference_matrix']['status'] = 'pass' + promoted['inference_matrix']['reported_precision'] = ( + 'Exact clean-head P100 Stage-B matrix passed validator tolerances on CuPy/Torch. ' + 'The dedicated nonzero-effect Hausman fixture was applicable on both physical GPU backends ' + 'with df=1 and statistic/p-value differences versus NumPy below 1.1e-13 and 2.2e-14, respectively. ' + 'The historical focused disconnected two-way FE artifact remains supplementary evidence for the ' + 'unchanged df_resid=1/effect_rank=7/incidence_components=3 inference boundary.' + ) + promoted['validation_tier'] = 'remote-full' + promoted['timing_scope'] = { + 'collected': False, + 'reason': 'Correctness/backend-provenance validation only; no benchmark timing was measured.', + } + promoted['reproducibility'] = { + 'exact_git_sha': measurement_sha, + 'working_tree_clean': True, + 'runner': 'dev/benchmarks/validate_panel_stage_b_gpu.py', + 'focused_runner': 'dev/benchmarks/validate_panel_stage_b_disconnected_fe_gpu.py', + 'raw_artifact_path': raw_rel, + 'raw_artifact_git_blob_sha': raw_blob, + 'repository_commit': artifact_commit, + 'focused_artifact_path': focused_rel, + 'focused_artifact_git_blob_sha': focused_blob, + 'focused_measurement_git_sha': historical_measurement_sha, + 'focused_repository_commit': historical_artifact_commit, + } + promoted['uncovered_reasons'] = [ + 'Performance timing was not collected by this correctness-only physical validation and must not be inferred from this source.', + 'The four standard/explicit-RE-constant Hausman datasets remain structured inapplicable because their covariance differences are materially indefinite; a separate nonzero-effect fitted fixture physically exercises the applicable statistic/p-value/df branch on both GPU backends.', + "The runner could not resolve an installed CuPy distribution version through importlib.metadata, so the source records the CuPy package version as null while executed_backend='cupy' proves physical backend execution.", + 'The focused disconnected-FE artifact was measured earlier at a57efcea and is retained only as supplementary validation evidence for an unchanged numerical path; it is not represented as a 2701aa9f measurement or expanded into timing rows.', + ] + promoted['backend_results'] = {} + for backend in ('cupy', 'torch'): + backend_raw = raw['backends'][backend] + promoted['backend_results'][backend] = { + 'status': 'success', + 'executed_backend': backend, + 'model_cases': { + case_id: case['status'] for case_id, case in backend_raw['models'].items() + }, + 'diagnostics': deepcopy(backend_raw['diagnostics']), + } + + new_source_path.write_text( + json.dumps(promoted, indent=2, ensure_ascii=False) + '\n', encoding='utf-8' + ) + + from dev.benchmarks.frontend_data.canonical import source_sha256 + promoted_sha256 = source_sha256(new_source_path) + source_id = f'panel-stage-b-pr122-20260809-{promoted_sha256[:12]}' + + manifest_path = root / 'dev/benchmarks/frontend_sources.json' + manifest = json.loads(manifest_path.read_text(encoding='utf-8')) + entries = [ + entry for entry in manifest['sources'] + if entry.get('comparison_id') == 'panel-stage-b-pr122-20260809' + ] + assert len(entries) == 1 + entry = entries[0] + entry.update({ + 'source_id': source_id, + 'path': new_source_rel, + 'original_path': raw_rel, + 'sha256': promoted_sha256, + 'parser': 'panel_stage_b_physical_validation', + 'parser_version': '1.0', + 'env_id': 'remote-p100-pr122-20260809', + 'required': True, + 'allowed_issue_codes': [], + 'source_date': '2026-08-09', + 'measurement_git_sha': measurement_sha, + 'raw_git_sha': measurement_sha, + 'provenance_note': ( + 'Final PR #122 Stage-B correctness/backend-provenance source. Exact clean P100 measurement ' + f'{measurement_sha} passed all 17 estimator cases and five Hausman diagnostics on each of CuPy and Torch, ' + 'with requested/executed backend identity and no CPU fallback. The dedicated ' + 'hausman_applicable_nonzero_effect fixture is applicable on both GPU backends with df=1 and ' + 'statistic/p-value agreement versus NumPy at floating-point noise. Raw artifact ' + f'{raw_rel} has Git blob {raw_blob} and was committed by {artifact_commit}. ' + f'The older focused disconnected-FE artifact {focused_rel} (Git blob {focused_blob}, ' + f'measurement {historical_measurement_sha}) is retained only as supplementary evidence for the unchanged df=1 path. ' + 'No timing was collected.' + ), + }) + manifest_path.write_text(json.dumps(manifest, indent=2) + '\n', encoding='utf-8') + + coverage_path = root / 'dev/benchmarks/benchmark_coverage_matrix.json' + coverage = json.loads(coverage_path.read_text(encoding='utf-8')) + panel_rows = [c for c in coverage['capabilities'] if c['capability_id'] == 'panel-estimation'] + assert len(panel_rows) == 1 + panel_row = panel_rows[0] + panel_row['source_ids'] = [ + source_id if sid.startswith('panel-stage-b-pr122-20260809-') else sid + for sid in panel_row['source_ids'] + ] + panel_row['disposition'] = ( + 'June timing rows cover aligned PanelOLS and RandomEffects. PR #122 adds canonical validation-only ' + 'CuPy/Torch evidence for the 17-case Stage-B estimator matrix, five Hausman diagnostics per backend ' + '(including a physically applicable nonzero-effect statistic/p-value/df path), backend provenance, ' + 'Stage-A inference regression, and the disconnected two-way FE df=1 physical boundary; broader ' + 'performance/covariance timing remains open.' + ) + coverage_path.write_text(json.dumps(coverage, indent=2) + '\n', encoding='utf-8') + + catalog_path = root / 'dev/benchmarks/benchmark_source_catalog.json' + catalog = json.loads(catalog_path.read_text(encoding='utf-8')) + raw_rules = [r for r in catalog['rules'] if r['rule_id'] == 'pr122-panel-stage-b-physical-validation'] + assert len(raw_rules) == 1 + raw_rule = raw_rules[0] + raw_rule.pop('path', None) + raw_rule['path_regex'] = r'^results/pr122_p100/panel_stage_b_gpu_validation_.*[.]json$' + raw_rule['reason'] = ( + 'Immutable full Stage-B physical correctness/backend-provenance artifacts for PR #122 are retained ' + 'for audit; only the currently SHA-protected normalized canonical source is registered in frontend_sources.json.' + ) + historical_rule_id = 'superseded-pr122-panel-stage-b-canonical-a57efcea' + if not any(r['rule_id'] == historical_rule_id for r in catalog['rules']): + insert_at = catalog['rules'].index(raw_rule) + 1 + catalog['rules'].insert(insert_at, { + 'rule_id': historical_rule_id, + 'priority': 21, + 'path': old_source_rel, + 'classification': 'superseded_or_duplicate', + 'canonical_eligible': False, + 'provenance_status': 'complete', + 'timing_protocol_status': 'not_applicable', + 'statistical_alignment_status': 'accepted', + 'superseded_by': new_source_rel, + 'issue': '#93', + 'reason': ( + 'The 42-row a57efcea Stage-B canonical validation source is retained immutably for audit but ' + 'is superseded by the exact-clean-head 2701aa9f P100 source that also physically validates an applicable Hausman branch.' + ), + }) + catalog_path.write_text(json.dumps(catalog, indent=2) + '\n', encoding='utf-8') + + test_path = root / 'dev/tests/test_panel_stage_b_frontend_source.py' + text = test_path.read_text(encoding='utf-8') + text = text.replace('panel_stage_b_pr122_p100_20260809.json', 'panel_stage_b_pr122_p100_20260809_2701aa9f.json') + text = text.replace('panel_stage_b_gpu_validation_a57efcea.json', 'panel_stage_b_gpu_validation_2701aa9f.json') + text = re.sub(r'EXPECTED_SHA256 = "[0-9a-f]+"', f'EXPECTED_SHA256 = "{promoted_sha256}"', text) + text = re.sub(r'RAW_EXPECTED_BLOB_SHA = "[0-9a-f]+"', f'RAW_EXPECTED_BLOB_SHA = "{raw_blob}"', text) + text = re.sub(r'SOURCE_ID = "[^"]+"', f'SOURCE_ID = "{source_id}"', text) + text = re.sub(r'MEASUREMENT_SHA = "[0-9a-f]+"', f'MEASUREMENT_SHA = "{measurement_sha}"', text) + text = re.sub( + r'ARTIFACT_COMMIT = "[0-9a-f]+"', + f'ARTIFACT_COMMIT = "{artifact_commit}"\nFOCUSED_MEASUREMENT_SHA = "{historical_measurement_sha}"\nFOCUSED_ARTIFACT_COMMIT = "{historical_artifact_commit}"', + text, + count=1, + ) + text = text.replace('assert data["compatibility_matrix"]["cupy"]["diagnostics"] == "4/4"', 'assert data["compatibility_matrix"]["cupy"]["diagnostics"] == "5/5"') + text = text.replace('assert data["compatibility_matrix"]["torch"]["diagnostics"] == "4/4"', 'assert data["compatibility_matrix"]["torch"]["diagnostics"] == "5/5"') + text = text.replace('assert focused_meta["repository_commit"] == ARTIFACT_COMMIT', 'assert focused_meta["repository_commit"] == FOCUSED_ARTIFACT_COMMIT') + text = text.replace('assert focused["git_sha"] == MEASUREMENT_SHA', 'assert focused["git_sha"] == FOCUSED_MEASUREMENT_SHA') + marker = ' assert data["environment"]["gpu"] == "Tesla P100-SXM2-16GB"\n' + assert marker in text + diagnostic_contract = ''' for backend in ("cupy", "torch"):\n diagnostic = data["backend_results"][backend]["diagnostics"][\n "hausman_applicable_nonzero_effect"\n ]\n assert diagnostic["status"] == "success"\n assert diagnostic["applicable"] is True\n assert diagnostic["reason"] is None\n assert diagnostic["df"] == 1.0\n assert 0.0 <= diagnostic["pvalue"] <= 1.0\n assert diagnostic["statistic"] >= 0.0\n assert diagnostic["max_abs_differences"]["statistic"] < 2e-13\n assert diagnostic["max_abs_differences"]["pvalue"] < 5e-14\n\n''' + text = text.replace(marker, diagnostic_contract + marker, 1) + + new_parser_test = '''def test_pr122_parser_emits_validation_only_frontend_runs() -> None:\n from dev.benchmarks.frontend_data.parsers import (\n parse_panel_stage_b_physical_validation,\n )\n\n runs, models, warnings = parse_panel_stage_b_physical_validation(\n SOURCE_PATH, ENV_ID\n )\n\n assert warnings == []\n assert len(runs) == 44\n assert len(models) == 6\n assert {run["backend"] for run in runs} == {"cupy", "torch"}\n assert {model["model_id"] for model in models} == {\n "PooledOLS",\n "BetweenOLS",\n "FirstDifferenceOLS",\n "PanelOLS",\n "RandomEffects",\n "FamaMacBeth",\n }\n assert all("timing" not in run["metrics"] for run in runs)\n assert all("speedup" not in run["metrics"] for run in runs)\n assert all(run["metrics"]["validation"]["status"] == "pass" for run in runs)\n assert all(\n run["parameters"]["measurement_git_sha"] == MEASUREMENT_SHA for run in runs\n )\n assert all(run["parameters"]["working_tree_clean"] is True for run in runs)\n\n hausman = [run for run in runs if run["parameters"].get("diagnostic") == "hausman"]\n assert len(hausman) == 10\n assert all("inference" not in run["metrics"] for run in hausman)\n applicable = [\n run for run in hausman\n if run["parameters"].get("diagnostic_fixture") == "nonzero-effect-applicable"\n ]\n assert len(applicable) == 2\n assert {run["backend"] for run in applicable} == {"cupy", "torch"}\n assert all(run["parameters"]["applicable"] is True for run in applicable)\n assert {run["parameters"]["df"] for run in applicable} == {1.0}\n assert all(run["parameters"]["statistic"] >= 0.0 for run in applicable)\n assert all(0.0 <= run["parameters"]["pvalue"] <= 1.0 for run in applicable)\n structured_inapplicable = [run for run in hausman if run not in applicable]\n assert len(structured_inapplicable) == 8\n assert all(run["parameters"]["applicable"] is False for run in structured_inapplicable)\n assert {run["parameters"]["parameterization"] for run in hausman} == {\n "standard",\n "re-explicit-constant",\n }\n assert {run["variant"] for run in hausman} == {\n "hausman-balanced",\n "hausman-unbalanced",\n "hausman-re-explicit-constant-balanced",\n "hausman-re-explicit-constant-unbalanced",\n "hausman-applicable-nonzero-effect",\n }\n\n estimator_runs = [run for run in runs if run not in hausman]\n assert len(estimator_runs) == 34\n assert all(run["metrics"]["inference"]["ok"] is True for run in estimator_runs)\n\n explicit_re = [\n run\n for run in estimator_runs\n if run["model_id"] == "RandomEffects"\n and run["variant"].startswith("explicit-constant-")\n ]\n assert len(explicit_re) == 4\n assert {run["scale"]["n_features"] for run in explicit_re} == {3}\n\n''' + text, count = re.subn( + r'def test_pr122_parser_emits_validation_only_frontend_runs\(\) -> None:\n.*?(?=\ndef test_pr122_parser_is_registered_in_manifest)', + new_parser_test, + text, + flags=re.S, + ) + assert count == 1 + test_path.write_text(text, encoding='utf-8') + + applicable_test_path = root / 'dev/tests/test_panel_stage_b_applicable_hausman_parser.py' + applicable_text = applicable_test_path.read_text(encoding='utf-8') + applicable_text = applicable_text.replace( + 'panel_stage_b_pr122_p100_20260809.json', + 'panel_stage_b_pr122_p100_20260809_2701aa9f.json', + ) + applicable_test_path.write_text(applicable_text, encoding='utf-8') + + en_path = root / 'docs/en/changelog.md' + en_lines = en_path.read_text(encoding='utf-8').splitlines() + en_idx = [i for i, line in enumerate(en_lines) if line.startswith('- A Ready-for-review audit reopened the physical gate')] + assert len(en_idx) == 1 + en_lines[en_idx[0]] = ( + '- The reopened physical gate is now closed on exact clean measurement head ' + '`2701aa9feb3796c33c94e6480fcb78c80c6a809c`: Tesla P100 CuPy and Torch each passed all 17 estimator cases and all five Hausman diagnostics with requested/executed backend identity and no CPU fallback. ' + 'The dedicated 48-observation nonzero-effect fixture is `applicable=true` on both backends with df=1; its Hausman statistic differs from NumPy by at most `1.10e-13` and p-value by at most `2.19e-14`. ' + 'The promoted 44-row canonical validation source preserves statistic/pvalue/df for that branch, while the older 42-row a57efcea source remains historical audit evidence. No timing or speedup claim is made.' + ) + en_path.write_text('\n'.join(en_lines) + '\n', encoding='utf-8') + + cn_path = root / 'docs/cn/changelog.md' + cn_lines = cn_path.read_text(encoding='utf-8').splitlines() + cn_idx = [i for i, line in enumerate(cn_lines) if line.startswith('- Ready-for-review 审计因此重新打开 physical gate')] + assert len(cn_idx) == 1 + cn_lines[cn_idx[0]] = ( + '- 重新打开的 physical gate 已在精确 clean measurement head ' + '`2701aa9feb3796c33c94e6480fcb78c80c6a809c` 上闭合：Tesla P100 的 CuPy 与 Torch 各自通过全部 17 个 estimator case 和 5 个 Hausman diagnostic，requested/executed backend 一致且没有 CPU fallback。' + '新增的 48-observation nonzero-effect fixture 在两个 backend 上均为 `applicable=true`、df=1；Hausman statistic 相对 NumPy 的最大差异不超过 `1.10e-13`，p-value 不超过 `2.19e-14`。' + '新的 44-row canonical validation source 保留该分支的 statistic/pvalue/df；旧的 42-row a57efcea source 继续作为历史审计证据保留。本次证据不包含 timing 或 speedup 声明。' + ) + cn_path.write_text('\n'.join(cn_lines) + '\n', encoding='utf-8') + + review_path = root / 'dev/reviews/pr122_physical_gpu_validation.md' + review_path.write_text(f'''# PR #122 Panel Stage B physical GPU validation\n\n## Physical acceptance status\n\n**PHYSICAL_GPU_ACCEPTED** for the Stage-B runner measured at exact clean implementation head `{measurement_sha}`.\n\nThis status covers the active physical correctness/backend-provenance gate only. Exact-final-head hosted CI and a fresh `.claude/skills/code-review.md` review remain lifecycle gates after evidence promotion; the physical runner itself must not change without another P100 rerun.\n\n## Accepted full P100 artifact\n\n- path: `{raw_rel}`\n- measurement SHA: `{measurement_sha}`\n- artifact repository commit: `{artifact_commit}`\n- Git blob: `{raw_blob}`\n- schema version: 2\n- working tree clean: true\n- top-level status: success\n- GPU: Tesla P100-SXM2-16GB\n- Python: 3.9.16\n- NumPy: 1.24.2\n- SciPy: 1.10.1\n- Torch: 2.0.0\n- timing collected: false\n\nFor both CuPy and Torch, all 17 estimator cases passed with the requested backend actually executed and no CPU fallback.\n\n## Hausman branch coverage\n\nEach backend passed five Hausman diagnostics:\n\n1. `hausman_balanced` — structured `applicable=false` / non-PSD covariance difference;\n2. `hausman_explicit_re_constant_balanced` — structured `applicable=false`;\n3. `hausman_unbalanced` — structured `applicable=false`;\n4. `hausman_explicit_re_constant_unbalanced` — structured `applicable=false`;\n5. `hausman_applicable_nonzero_effect` — **`applicable=true`**, df=1.\n\nFor the dedicated applicable fixture, CuPy recorded statistic `1.1965942530851057` and p-value `0.27400344142676447`; Torch recorded statistic `1.1965942530849238` and p-value `0.2740034414268009`; the NumPy reference is statistic `1.196594253085033`, p-value `0.274003441426779`, df=1. Maximum statistic differences are `7.26e-14` (CuPy) and `1.09e-13` (Torch), and all FE/RE coefficient/covariance differences are below `1e-12`.\n\nThe fixture uses seed 20260810, 12 entities, 4 observations per entity, one slope, entity-effect scale 0.005, and noise scale 0.1. Its NumPy FE-minus-RE diagnostic covariance margin is `4.6413153162319366e-05`, safely above the hosted stability guard.\n\n## Supplementary disconnected-FE evidence\n\nThe focused disconnected two-way FE artifact remains valid supplementary evidence for an unchanged numerical path:\n\n- path: `{focused_rel}`\n- measurement SHA: `{historical_measurement_sha}`\n- artifact repository commit: `{historical_artifact_commit}`\n- Git blob: `{focused_blob}`\n- legacy residual df: 0\n- component-aware/public residual df: 1\n- effect rank: 7\n- incidence components: 3\n- CuPy/Torch confidence intervals agree with NumPy at floating-point noise.\n\nIt is deliberately identified as historical supplementary evidence rather than relabeled as a `{measurement_sha}` measurement.\n\n## Promoted canonical evidence\n\n- canonical path: `{new_source_rel}`\n- canonical SHA-256: `{promoted_sha256}`\n- source id: `{source_id}`\n- validation rows: 44 = 17 estimator cases x 2 backends + 5 Hausman diagnostics x 2 backends\n- timing/speedup: absent by contract\n\nThe parser requires the dedicated applicable row to preserve finite nonnegative statistic, p-value in [0,1], and positive df; missing or invalid numeric evidence fails closed. The older 42-row canonical source remains in the repository as explicitly superseded historical audit evidence and is no longer the registered source.\n\n## Physical conclusion\n\nThe P2 finding “Require an applicable Hausman case in the GPU gate” is physically closed. Both physical backends now exercise the applicable statistic/p-value/df path and the structured-inapplicable path without fallback.\n\n**Physical gate: ACCEPTED.**\n''', encoding='utf-8') + + print('promoted source:', new_source_rel) + print('source sha256:', promoted_sha256) + print('source id:', source_id) + print('raw blob:', raw_blob) + PY + - name: Generate canonical frontend assets + run: | + python dev/benchmarks/generate_benchmark_data.py \ + --out frontend/public/data/benchmark_data.json \ + --report frontend/public/data/parse_report.json \ + --inventory-out frontend/public/data/source_inventory.json \ + --deterministic --strict-sources + - uses: actions/setup-node@v4 + with: + node-version: '20' + - name: Build docs mirror + working-directory: frontend + run: | + npm ci + npm run build + - name: Run focused canonical and catalog gates + run: | + python -m pytest \ + dev/tests/test_panel_stage_b_frontend_source.py \ + dev/tests/test_panel_stage_b_applicable_hausman_parser.py \ + dev/tests/test_benchmark_frontend_data.py \ + dev/tests/test_benchmark_catalog.py \ + dev/tests/test_benchmark_inventory_v2.py \ + dev/tests/test_frontend_contracts.py \ + dev/tests/test_frontend_domain_coverage.py -q + python dev/benchmarks/generate_benchmark_data.py --check --strict-sources + git diff --check + - name: Commit promoted evidence and remove one-shot workflow + run: | + rm .github/workflows/pr122-finalize-evidence.yml + git config user.name 'github-actions[bot]' + git config user.email '41898282+github-actions[bot]@users.noreply.github.com' + echo 'Final changed paths:' + git status --short + git add -A + git commit -m 'benchmark: finalize PR122 Stage B physical evidence' + git push origin HEAD:agent/panel-p1-stage-b-diagnostics From f45759bce5697be682187e29214bdb4231a390ac Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 22:33:13 +0800 Subject: [PATCH 156/165] test: update PR122 canonical source contract --- dev/tests/test_benchmark_catalog.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dev/tests/test_benchmark_catalog.py b/dev/tests/test_benchmark_catalog.py index 209c57645..56729b848 100644 --- a/dev/tests/test_benchmark_catalog.py +++ b/dev/tests/test_benchmark_catalog.py @@ -110,7 +110,7 @@ def test_coverage_matrix_is_referentially_complete(coverage_matrix, manifest): ] assert rows["panel-estimation"]["source_ids"] == [ "new-modules-20260624-bcbdb676223b", - "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "panel-stage-b-pr122-20260809-2056f836bfe2", ] assert rows["distribution-api"]["issue"] == "#101" assert rows["feature-selection-knockoff"]["issue"] == "#103" From 624c7d1e910ef1433bde4e03fdfb8e7d8aa84c4b Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 22:33:49 +0800 Subject: [PATCH 157/165] ci: retry PR122 evidence finalization --- .../pr122-finalize-evidence-retry.yml | 112 ++++++++++++++++++ 1 file changed, 112 insertions(+) create mode 100644 .github/workflows/pr122-finalize-evidence-retry.yml diff --git a/.github/workflows/pr122-finalize-evidence-retry.yml b/.github/workflows/pr122-finalize-evidence-retry.yml new file mode 100644 index 000000000..01fa7f8a1 --- /dev/null +++ b/.github/workflows/pr122-finalize-evidence-retry.yml @@ -0,0 +1,112 @@ +name: PR122 retry evidence finalization + +on: + push: + branches: [agent/panel-p1-stage-b-diagnostics] + paths: + - '.github/workflows/pr122-finalize-evidence-retry.yml' + +permissions: + contents: write + +jobs: + prepare-retry: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + fetch-depth: 0 + - name: Update Stage-B domain coverage contract + run: | + python - <<'PY' + from pathlib import Path + import re + + path = Path('dev/tests/test_frontend_domain_coverage.py') + text = path.read_text(encoding='utf-8') + replacement = '''def test_panel_stage_b_physical_validation_is_published_without_timing(canonical_output): + output, _, _, _ = canonical_output + rows = [ + run + for run in output["runs"] + if run["source"]["source_id"] + == "panel-stage-b-pr122-20260809-2056f836bfe2" + ] + assert len(rows) == 44 + assert {run["backend"] for run in rows} == {"cupy", "torch"} + assert {run["model_id"] for run in rows} == { + "PooledOLS", + "BetweenOLS", + "FirstDifferenceOLS", + "PanelOLS", + "RandomEffects", + "FamaMacBeth", + } + assert all(run["metrics"]["validation"]["status"] == "pass" for run in rows) + assert all("timing" not in run["metrics"] for run in rows) + assert all("speedup" not in run["metrics"] for run in rows) + assert all( + run["parameters"]["measurement_git_sha"] + == "2701aa9feb3796c33c94e6480fcb78c80c6a809c" + for run in rows + ) + + hausman = [run for run in rows if run["parameters"].get("diagnostic") == "hausman"] + assert len(hausman) == 10 + applicable = [ + run + for run in hausman + if run["parameters"].get("diagnostic_fixture") == "nonzero-effect-applicable" + ] + assert len(applicable) == 2 + assert {run["backend"] for run in applicable} == {"cupy", "torch"} + assert all(run["parameters"]["applicable"] is True for run in applicable) + assert {run["parameters"]["df"] for run in applicable} == {1.0} + assert all(run["parameters"]["statistic"] >= 0.0 for run in applicable) + assert all(0.0 <= run["parameters"]["pvalue"] <= 1.0 for run in applicable) + + inapplicable = [run for run in hausman if run not in applicable] + assert len(inapplicable) == 8 + assert all(run["parameters"]["applicable"] is False for run in inapplicable) + assert {run["parameters"]["parameterization"] for run in hausman} == { + "standard", + "re-explicit-constant", + } + assert {run["variant"] for run in hausman} == { + "hausman-balanced", + "hausman-unbalanced", + "hausman-re-explicit-constant-balanced", + "hausman-re-explicit-constant-unbalanced", + "hausman-applicable-nonzero-effect", + } + +''' + text, count = re.subn( + r'def test_panel_stage_b_physical_validation_is_published_without_timing\(canonical_output\):\n.*?(?=\ndef test_unsupervised_exposes_complete_source_matrix)', + replacement, + text, + flags=re.S, + ) + assert count == 1, count + text = text.replace( + 'assert len(output["runs"]) == 1860\n assert report["runs_generated"] == 1860', + 'assert len(output["runs"]) == 1862\n assert report["runs_generated"] == 1862', + ) + path.write_text(text, encoding='utf-8') + + workflow = Path('.github/workflows/pr122-finalize-evidence.yml') + workflow.write_text( + workflow.read_text(encoding='utf-8') + + '\n# retry after final Stage-B domain coverage contract update\n', + encoding='utf-8', + ) + PY + - name: Commit retry preparation and remove helper + run: | + rm .github/workflows/pr122-finalize-evidence-retry.yml + git diff --check + git config user.name 'github-actions[bot]' + git config user.email '41898282+github-actions[bot]@users.noreply.github.com' + git add -A + git commit -m 'test: align PR122 final frontend coverage' + git push origin HEAD:agent/panel-p1-stage-b-diagnostics From 7b54cfb03f8faa57fc11bc3db2c022dc35404c70 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 22:36:14 +0800 Subject: [PATCH 158/165] ci: repair PR122 evidence retry carrier --- .../pr122-finalize-evidence-retry.yml | 72 +++---------------- 1 file changed, 10 insertions(+), 62 deletions(-) diff --git a/.github/workflows/pr122-finalize-evidence-retry.yml b/.github/workflows/pr122-finalize-evidence-retry.yml index 01fa7f8a1..a09f85458 100644 --- a/.github/workflows/pr122-finalize-evidence-retry.yml +++ b/.github/workflows/pr122-finalize-evidence-retry.yml @@ -17,70 +17,18 @@ jobs: with: fetch-depth: 0 - name: Update Stage-B domain coverage contract + env: + REPLACEMENT_B64: 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 run: | python - <<'PY' - from pathlib import Path + import base64 + import os import re + from pathlib import Path path = Path('dev/tests/test_frontend_domain_coverage.py') text = path.read_text(encoding='utf-8') - replacement = '''def test_panel_stage_b_physical_validation_is_published_without_timing(canonical_output): - output, _, _, _ = canonical_output - rows = [ - run - for run in output["runs"] - if run["source"]["source_id"] - == "panel-stage-b-pr122-20260809-2056f836bfe2" - ] - assert len(rows) == 44 - assert {run["backend"] for run in rows} == {"cupy", "torch"} - assert {run["model_id"] for run in rows} == { - "PooledOLS", - "BetweenOLS", - "FirstDifferenceOLS", - "PanelOLS", - "RandomEffects", - "FamaMacBeth", - } - assert all(run["metrics"]["validation"]["status"] == "pass" for run in rows) - assert all("timing" not in run["metrics"] for run in rows) - assert all("speedup" not in run["metrics"] for run in rows) - assert all( - run["parameters"]["measurement_git_sha"] - == "2701aa9feb3796c33c94e6480fcb78c80c6a809c" - for run in rows - ) - - hausman = [run for run in rows if run["parameters"].get("diagnostic") == "hausman"] - assert len(hausman) == 10 - applicable = [ - run - for run in hausman - if run["parameters"].get("diagnostic_fixture") == "nonzero-effect-applicable" - ] - assert len(applicable) == 2 - assert {run["backend"] for run in applicable} == {"cupy", "torch"} - assert all(run["parameters"]["applicable"] is True for run in applicable) - assert {run["parameters"]["df"] for run in applicable} == {1.0} - assert all(run["parameters"]["statistic"] >= 0.0 for run in applicable) - assert all(0.0 <= run["parameters"]["pvalue"] <= 1.0 for run in applicable) - - inapplicable = [run for run in hausman if run not in applicable] - assert len(inapplicable) == 8 - assert all(run["parameters"]["applicable"] is False for run in inapplicable) - assert {run["parameters"]["parameterization"] for run in hausman} == { - "standard", - "re-explicit-constant", - } - assert {run["variant"] for run in hausman} == { - "hausman-balanced", - "hausman-unbalanced", - "hausman-re-explicit-constant-balanced", - "hausman-re-explicit-constant-unbalanced", - "hausman-applicable-nonzero-effect", - } - -''' + replacement = base64.b64decode(os.environ['REPLACEMENT_B64']).decode('utf-8') text, count = re.subn( r'def test_panel_stage_b_physical_validation_is_published_without_timing\(canonical_output\):\n.*?(?=\ndef test_unsupervised_exposes_complete_source_matrix)', replacement, @@ -88,10 +36,10 @@ jobs: flags=re.S, ) assert count == 1, count - text = text.replace( - 'assert len(output["runs"]) == 1860\n assert report["runs_generated"] == 1860', - 'assert len(output["runs"]) == 1862\n assert report["runs_generated"] == 1862', - ) + old_count = 'assert len(output["runs"]) == 1860\n assert report["runs_generated"] == 1860' + new_count = 'assert len(output["runs"]) == 1862\n assert report["runs_generated"] == 1862' + assert old_count in text + text = text.replace(old_count, new_count) path.write_text(text, encoding='utf-8') workflow = Path('.github/workflows/pr122-finalize-evidence.yml') From 8eff35c24b59f9077bcd963440cda31d23af005a Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 22:37:43 +0800 Subject: [PATCH 159/165] ci: isolate PR122 retry from workflow writes --- .../workflows/pr122-finalize-evidence-retry.yml | 17 ++++------------- 1 file changed, 4 insertions(+), 13 deletions(-) diff --git a/.github/workflows/pr122-finalize-evidence-retry.yml b/.github/workflows/pr122-finalize-evidence-retry.yml index a09f85458..dd895e043 100644 --- a/.github/workflows/pr122-finalize-evidence-retry.yml +++ b/.github/workflows/pr122-finalize-evidence-retry.yml @@ -1,4 +1,4 @@ -name: PR122 retry evidence finalization +name: PR122 retry evidence contract on: push: @@ -10,7 +10,7 @@ permissions: contents: write jobs: - prepare-retry: + update-contract: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 @@ -25,7 +25,6 @@ jobs: import os import re from pathlib import Path - path = Path('dev/tests/test_frontend_domain_coverage.py') text = path.read_text(encoding='utf-8') replacement = base64.b64decode(os.environ['REPLACEMENT_B64']).decode('utf-8') @@ -41,20 +40,12 @@ jobs: assert old_count in text text = text.replace(old_count, new_count) path.write_text(text, encoding='utf-8') - - workflow = Path('.github/workflows/pr122-finalize-evidence.yml') - workflow.write_text( - workflow.read_text(encoding='utf-8') - + '\n# retry after final Stage-B domain coverage contract update\n', - encoding='utf-8', - ) PY - - name: Commit retry preparation and remove helper + - name: Commit only the domain contract run: | - rm .github/workflows/pr122-finalize-evidence-retry.yml git diff --check git config user.name 'github-actions[bot]' git config user.email '41898282+github-actions[bot]@users.noreply.github.com' - git add -A + git add dev/tests/test_frontend_domain_coverage.py git commit -m 'test: align PR122 final frontend coverage' git push origin HEAD:agent/panel-p1-stage-b-diagnostics From 6b681dcac8d833eb495459fffc5edbf40dd39b55 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Sun, 9 Aug 2026 14:37:51 +0000 Subject: [PATCH 160/165] test: align PR122 final frontend coverage --- dev/tests/test_frontend_domain_coverage.py | 35 +++++++++++++++++----- 1 file changed, 28 insertions(+), 7 deletions(-) diff --git a/dev/tests/test_frontend_domain_coverage.py b/dev/tests/test_frontend_domain_coverage.py index 7b0f7b2d1..d77c40a9f 100644 --- a/dev/tests/test_frontend_domain_coverage.py +++ b/dev/tests/test_frontend_domain_coverage.py @@ -303,9 +303,9 @@ def test_panel_stage_b_physical_validation_is_published_without_timing(canonical run for run in output["runs"] if run["source"]["source_id"] - == "panel-stage-b-pr122-20260809-a6e47b9dec9c" + == "panel-stage-b-pr122-20260809-2056f836bfe2" ] - assert len(rows) == 42 + assert len(rows) == 44 assert {run["backend"] for run in rows} == {"cupy", "torch"} assert {run["model_id"] for run in rows} == { "PooledOLS", @@ -320,17 +320,38 @@ def test_panel_stage_b_physical_validation_is_published_without_timing(canonical assert all("speedup" not in run["metrics"] for run in rows) assert all( run["parameters"]["measurement_git_sha"] - == "a57efcea29b0e87ecb89865c5a6902d5773812c6" + == "2701aa9feb3796c33c94e6480fcb78c80c6a809c" for run in rows ) hausman = [run for run in rows if run["parameters"].get("diagnostic") == "hausman"] - assert len(hausman) == 8 - assert all(run["parameters"]["applicable"] is False for run in hausman) + assert len(hausman) == 10 + applicable = [ + run + for run in hausman + if run["parameters"].get("diagnostic_fixture") == "nonzero-effect-applicable" + ] + assert len(applicable) == 2 + assert {run["backend"] for run in applicable} == {"cupy", "torch"} + assert all(run["parameters"]["applicable"] is True for run in applicable) + assert {run["parameters"]["df"] for run in applicable} == {1.0} + assert all(run["parameters"]["statistic"] >= 0.0 for run in applicable) + assert all(0.0 <= run["parameters"]["pvalue"] <= 1.0 for run in applicable) + + inapplicable = [run for run in hausman if run not in applicable] + assert len(inapplicable) == 8 + assert all(run["parameters"]["applicable"] is False for run in inapplicable) assert {run["parameters"]["parameterization"] for run in hausman} == { "standard", "re-explicit-constant", } + assert {run["variant"] for run in hausman} == { + "hausman-balanced", + "hausman-unbalanced", + "hausman-re-explicit-constant-balanced", + "hausman-re-explicit-constant-unbalanced", + "hausman-applicable-nonzero-effect", + } def test_unsupervised_exposes_complete_source_matrix(canonical_output): @@ -389,8 +410,8 @@ def test_unsupervised_exposes_complete_source_matrix(canonical_output): def test_generated_bundle_has_expected_complete_run_count(canonical_output): output, report, _, _ = canonical_output - assert len(output["runs"]) == 1860 - assert report["runs_generated"] == 1860 + assert len(output["runs"]) == 1862 + assert report["runs_generated"] == 1862 def test_missing_domain_sources_are_manifest_registered(canonical_output): From 99eea750aea98c049593db673bd6c95f05a01dd5 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 22:38:33 +0800 Subject: [PATCH 161/165] ci: run PR122 final evidence promotion --- .../workflows/pr122-finalize-evidence-v3.yml | 80 +++++++++++++++++++ 1 file changed, 80 insertions(+) create mode 100644 .github/workflows/pr122-finalize-evidence-v3.yml diff --git a/.github/workflows/pr122-finalize-evidence-v3.yml b/.github/workflows/pr122-finalize-evidence-v3.yml new file mode 100644 index 000000000..b0c0f607e --- /dev/null +++ b/.github/workflows/pr122-finalize-evidence-v3.yml @@ -0,0 +1,80 @@ +name: PR122 final evidence promotion v3 + +on: + push: + branches: [agent/panel-p1-stage-b-diagnostics] + paths: + - '.github/workflows/pr122-finalize-evidence-v3.yml' + +permissions: + contents: write + +jobs: + promote: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + fetch-depth: 0 + - uses: actions/setup-python@v5 + with: + python-version: '3.11' + - name: Install validation dependencies + run: python -m pip install -U pip pytest 'jsonschema[format]' + - name: Execute reviewed promotion step + run: | + python - <<'PY' + from pathlib import Path + source = Path('.github/workflows/pr122-finalize-evidence.yml').read_text(encoding='utf-8') + start_marker = " - name: Promote exact-head P100 evidence and contracts\n run: |\n" + end_marker = "\n - name: Generate canonical frontend assets" + start = source.index(start_marker) + len(start_marker) + end = source.index(end_marker, start) + block = source[start:end] + lines = [] + for line in block.splitlines(): + if line.startswith(' '): + lines.append(line[10:]) + elif line: + raise SystemExit(f'unexpected promotion indentation: {line!r}') + else: + lines.append('') + Path('/tmp/pr122-promote.sh').write_text('\n'.join(lines) + '\n', encoding='utf-8') + PY + bash /tmp/pr122-promote.sh + - name: Generate canonical frontend assets + run: | + python dev/benchmarks/generate_benchmark_data.py \ + --out frontend/public/data/benchmark_data.json \ + --report frontend/public/data/parse_report.json \ + --inventory-out frontend/public/data/source_inventory.json \ + --deterministic --strict-sources + - uses: actions/setup-node@v4 + with: + node-version: '20' + - name: Build docs mirror + working-directory: frontend + run: | + npm ci + npm run build + - name: Run focused promotion gates + run: | + python -m pytest \ + dev/tests/test_panel_stage_b_frontend_source.py \ + dev/tests/test_panel_stage_b_applicable_hausman_parser.py \ + dev/tests/test_benchmark_frontend_data.py \ + dev/tests/test_benchmark_catalog.py \ + dev/tests/test_benchmark_inventory_v2.py \ + dev/tests/test_frontend_contracts.py \ + dev/tests/test_frontend_domain_coverage.py -q + python dev/benchmarks/generate_benchmark_data.py --check --strict-sources + git diff --check + - name: Commit promoted evidence + run: | + git config user.name 'github-actions[bot]' + git config user.email '41898282+github-actions[bot]@users.noreply.github.com' + echo 'Promoted changed paths:' + git status --short + git add -A + git commit -m 'benchmark: finalize PR122 Stage B physical evidence' + git push origin HEAD:agent/panel-p1-stage-b-diagnostics From 764f4a932bdac55450040dabf1922c130f12b580 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Sun, 9 Aug 2026 14:39:15 +0000 Subject: [PATCH 162/165] benchmark: finalize PR122 Stage B physical evidence --- dev/benchmarks/benchmark_coverage_matrix.json | 259 +++++- dev/benchmarks/benchmark_source_catalog.json | 17 +- dev/benchmarks/frontend_sources.json | 111 ++- dev/reviews/pr122_physical_gpu_validation.md | 170 ++-- ...panel_stage_b_applicable_hausman_parser.py | 2 +- .../test_panel_stage_b_frontend_source.py | 56 +- .../benchmarks/data/benchmark_data.json | 792 ++++++++++-------- docs/assets/benchmarks/data/parse_report.json | 4 +- .../benchmarks/data/source_inventory.json | 70 +- docs/cn/changelog.md | 2 +- docs/en/changelog.md | 2 +- frontend/public/data/benchmark_data.json | 792 ++++++++++-------- frontend/public/data/parse_report.json | 4 +- frontend/public/data/source_inventory.json | 70 +- ..._stage_b_pr122_p100_20260809_2701aa9f.json | 545 ++++++++++++ 15 files changed, 2011 insertions(+), 885 deletions(-) create mode 100644 results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809_2701aa9f.json diff --git a/dev/benchmarks/benchmark_coverage_matrix.json b/dev/benchmarks/benchmark_coverage_matrix.json index 32400948e..296b0514b 100644 --- a/dev/benchmarks/benchmark_coverage_matrix.json +++ b/dev/benchmarks/benchmark_coverage_matrix.json @@ -2,25 +2,244 @@ "coverage_matrix_version": "1.0", "catalog_version": "2.0", "capabilities": [ - {"capability_id":"penalized-glm-fit","label":"Penalized GLM fit and solver performance","status":"canonical_current","source_ids":["penalized-glm-perf-20260622-e5baa1cbb516","glm-solver-20260623-1b6197d94d88"],"representative_dimensions":["family","loss","penalty","solver","backend","scale"]}, - {"capability_id":"coxph-breslow-efron-fit","label":"CoxPH Breslow and Efron fit coverage","status":"canonical_current","source_ids":["coxph-efron-20260622-7192358f4c6d","loss-functions-20260623-f7e2d070a3b7"],"representative_dimensions":["ties","backend","scale","external_reference"]}, - {"capability_id":"robust-quantile-fit","label":"Robust and quantile fit coverage","status":"partial_canonical","source_ids":["loss-functions-20260623-f7e2d070a3b7"],"representative_dimensions":["loss","backend","scale"],"issue":"#102","disposition":"Canonical rows exist for part of the maintained matrix; Bisquare, Fair, and complete all-backend coverage remain open."}, - {"capability_id":"ordered-inference","label":"Ordered and penalized inference validation","status":"partial_canonical","source_ids":["ordered-inference-20260712-c584a2bfa213"],"representative_dimensions":["method","inference_mode","backend","scale"],"issue":"#104","disposition":"Current inference evidence is canonical; broader Ordered crossover performance remains open."}, - {"capability_id":"unsupervised-fit","label":"Unsupervised estimator fit coverage","status":"partial_canonical","source_ids":["unsupervised-20260627-1ee68806e3ee"],"representative_dimensions":["estimator","backend","scale"],"issue":"#109","disposition":"Current estimator-level rows are canonical; NNDescent and operation-specific timings remain open."}, - {"capability_id":"panel-estimation","label":"Panel estimation and diagnostics coverage","status":"partial_canonical","source_ids":["new-modules-20260624-bcbdb676223b","panel-stage-b-pr122-20260809-a6e47b9dec9c"],"representative_dimensions":["estimator","backend","aligned_scale","physical_validation","diagnostics","inference_regression"],"issue":"#108","disposition":"June timing rows cover aligned PanelOLS and RandomEffects. PR #122 adds canonical validation-only CuPy/Torch evidence for the 17-case Stage-B estimator matrix, four Hausman parameterizations per backend, backend provenance, Stage-A inference regression, and the disconnected two-way FE df=1 physical boundary; broader performance/covariance timing remains open."}, - {"capability_id":"gam-nonparametric","label":"GAM and nonparametric coverage","status":"partial_canonical","source_ids":["new-modules-20260624-bcbdb676223b","p2-benchmark-20260617-e9c268d6a6f1"],"representative_dimensions":["method","backend","scale","external_reference"],"issue":"#106","disposition":"GAM and selected P2 rows are canonical; the maintained nonparametric matrix is incomplete."}, - {"capability_id":"covariance-estimation","label":"Covariance estimator coverage","status":"partial_canonical","source_ids":["p2-benchmark-20260617-e9c268d6a6f1"],"representative_dimensions":["estimator","backend","scale"],"issue":"#106","disposition":"Empirical covariance evidence exists; shrinkage, robust, and graphical estimator breadth remains open."}, - {"capability_id":"anova","label":"ANOVA coverage","status":"partial_canonical","source_ids":["new-modules-20260624-bcbdb676223b"],"representative_dimensions":["function","backend","scale"],"issue":"#104","disposition":"Available function rows are canonical; synchronization-safe crossover evidence remains open."}, - {"capability_id":"distribution-api","label":"Distribution API operations","status":"current_evidence_not_canonical_ready","source_ids":[],"issue":"#101","disposition":"June structured evidence exists but requires operation identity, provenance, timing, and parser audit before registration."}, - {"capability_id":"feature-selection-knockoff","label":"Feature Selection and Knockoff","status":"benchmark_data_gap","source_ids":[],"issue":"#103","disposition":"Existing evidence predates the minimum source date and remains audit-only."}, - {"capability_id":"linear-glm-inference","label":"Systematic linear and GLM inference","status":"benchmark_data_gap","source_ids":[],"issue":"#105","disposition":"A systematic coefficient, covariance, standard-error, test, interval, and likelihood matrix is not yet canonical."}, - {"capability_id":"penalized-coxph","label":"Penalized CoxPH paths","status":"current_evidence_not_canonical_ready","source_ids":[],"issue":"#107","disposition":"PR79/PR80 validation evidence exists but is not treated as canonical dashboard data without a dedicated audit or rerun."}, - {"capability_id":"ridge-cv","label":"RidgeCV","status":"canonical_current","source_ids":["cv-benchmark-20260807-1347184c988d"]}, - {"capability_id":"lasso-cv","label":"LassoCV","status":"canonical_current","source_ids":["cv-benchmark-20260807-1347184c988d"]}, - {"capability_id":"elasticnet-cv","label":"ElasticNetCV","status":"canonical_current","source_ids":["cv-benchmark-20260807-1347184c988d"]}, - {"capability_id":"logistic-regression-cv","label":"LogisticRegressionCV","status":"canonical_current","source_ids":["cv-benchmark-20260807-1347184c988d","cv-benchmark-pr116-20260807-bd8d512adced"],"representative_dimensions":["backend","pre_fix_failure","post_fix_success","physical_gpu"]}, - {"capability_id":"penalized-glm-cv","label":"PenalizedGLM_CV","status":"canonical_current","source_ids":["cv-benchmark-20260807-1347184c988d"]}, - {"capability_id":"coxph-cv","label":"CoxPHCV","status":"canonical_current","source_ids":["cv-benchmark-20260807-1347184c988d"]}, - {"capability_id":"multiple-testing-resampling","label":"Multiple testing and resampling utilities","status":"benchmark_data_gap","source_ids":[],"issue":"#109","disposition":"No current canonical utility-level statistical and timing matrix exists."} + { + "capability_id": "penalized-glm-fit", + "label": "Penalized GLM fit and solver performance", + "status": "canonical_current", + "source_ids": [ + "penalized-glm-perf-20260622-e5baa1cbb516", + "glm-solver-20260623-1b6197d94d88" + ], + "representative_dimensions": [ + "family", + "loss", + "penalty", + "solver", + "backend", + "scale" + ] + }, + { + "capability_id": "coxph-breslow-efron-fit", + "label": "CoxPH Breslow and Efron fit coverage", + "status": "canonical_current", + "source_ids": [ + "coxph-efron-20260622-7192358f4c6d", + "loss-functions-20260623-f7e2d070a3b7" + ], + "representative_dimensions": [ + "ties", + "backend", + "scale", + "external_reference" + ] + }, + { + "capability_id": "robust-quantile-fit", + "label": "Robust and quantile fit coverage", + "status": "partial_canonical", + "source_ids": [ + "loss-functions-20260623-f7e2d070a3b7" + ], + "representative_dimensions": [ + "loss", + "backend", + "scale" + ], + "issue": "#102", + "disposition": "Canonical rows exist for part of the maintained matrix; Bisquare, Fair, and complete all-backend coverage remain open." + }, + { + "capability_id": "ordered-inference", + "label": "Ordered and penalized inference validation", + "status": "partial_canonical", + "source_ids": [ + "ordered-inference-20260712-c584a2bfa213" + ], + "representative_dimensions": [ + "method", + "inference_mode", + "backend", + "scale" + ], + "issue": "#104", + "disposition": "Current inference evidence is canonical; broader Ordered crossover performance remains open." + }, + { + "capability_id": "unsupervised-fit", + "label": "Unsupervised estimator fit coverage", + "status": "partial_canonical", + "source_ids": [ + "unsupervised-20260627-1ee68806e3ee" + ], + "representative_dimensions": [ + "estimator", + "backend", + "scale" + ], + "issue": "#109", + "disposition": "Current estimator-level rows are canonical; NNDescent and operation-specific timings remain open." + }, + { + "capability_id": "panel-estimation", + "label": "Panel estimation and diagnostics coverage", + "status": "partial_canonical", + "source_ids": [ + "new-modules-20260624-bcbdb676223b", + "panel-stage-b-pr122-20260809-2056f836bfe2" + ], + "representative_dimensions": [ + "estimator", + "backend", + "aligned_scale", + "physical_validation", + "diagnostics", + "inference_regression" + ], + "issue": "#108", + "disposition": "June timing rows cover aligned PanelOLS and RandomEffects. PR #122 adds canonical validation-only CuPy/Torch evidence for the 17-case Stage-B estimator matrix, five Hausman diagnostics per backend (including a physically applicable nonzero-effect statistic/p-value/df path), backend provenance, Stage-A inference regression, and the disconnected two-way FE df=1 physical boundary; broader performance/covariance timing remains open." + }, + { + "capability_id": "gam-nonparametric", + "label": "GAM and nonparametric coverage", + "status": "partial_canonical", + "source_ids": [ + "new-modules-20260624-bcbdb676223b", + "p2-benchmark-20260617-e9c268d6a6f1" + ], + "representative_dimensions": [ + "method", + "backend", + "scale", + "external_reference" + ], + "issue": "#106", + "disposition": "GAM and selected P2 rows are canonical; the maintained nonparametric matrix is incomplete." + }, + { + "capability_id": "covariance-estimation", + "label": "Covariance estimator coverage", + "status": "partial_canonical", + "source_ids": [ + "p2-benchmark-20260617-e9c268d6a6f1" + ], + "representative_dimensions": [ + "estimator", + "backend", + "scale" + ], + "issue": "#106", + "disposition": "Empirical covariance evidence exists; shrinkage, robust, and graphical estimator breadth remains open." + }, + { + "capability_id": "anova", + "label": "ANOVA coverage", + "status": "partial_canonical", + "source_ids": [ + "new-modules-20260624-bcbdb676223b" + ], + "representative_dimensions": [ + "function", + "backend", + "scale" + ], + "issue": "#104", + "disposition": "Available function rows are canonical; synchronization-safe crossover evidence remains open." + }, + { + "capability_id": "distribution-api", + "label": "Distribution API operations", + "status": "current_evidence_not_canonical_ready", + "source_ids": [], + "issue": "#101", + "disposition": "June structured evidence exists but requires operation identity, provenance, timing, and parser audit before registration." + }, + { + "capability_id": "feature-selection-knockoff", + "label": "Feature Selection and Knockoff", + "status": "benchmark_data_gap", + "source_ids": [], + "issue": "#103", + "disposition": "Existing evidence predates the minimum source date and remains audit-only." + }, + { + "capability_id": "linear-glm-inference", + "label": "Systematic linear and GLM inference", + "status": "benchmark_data_gap", + "source_ids": [], + "issue": "#105", + "disposition": "A systematic coefficient, covariance, standard-error, test, interval, and likelihood matrix is not yet canonical." + }, + { + "capability_id": "penalized-coxph", + "label": "Penalized CoxPH paths", + "status": "current_evidence_not_canonical_ready", + "source_ids": [], + "issue": "#107", + "disposition": "PR79/PR80 validation evidence exists but is not treated as canonical dashboard data without a dedicated audit or rerun." + }, + { + "capability_id": "ridge-cv", + "label": "RidgeCV", + "status": "canonical_current", + "source_ids": [ + "cv-benchmark-20260807-1347184c988d" + ] + }, + { + "capability_id": "lasso-cv", + "label": "LassoCV", + "status": "canonical_current", + "source_ids": [ + "cv-benchmark-20260807-1347184c988d" + ] + }, + { + "capability_id": "elasticnet-cv", + "label": "ElasticNetCV", + "status": "canonical_current", + "source_ids": [ + "cv-benchmark-20260807-1347184c988d" + ] + }, + { + "capability_id": "logistic-regression-cv", + "label": "LogisticRegressionCV", + "status": "canonical_current", + "source_ids": [ + "cv-benchmark-20260807-1347184c988d", + "cv-benchmark-pr116-20260807-bd8d512adced" + ], + "representative_dimensions": [ + "backend", + "pre_fix_failure", + "post_fix_success", + "physical_gpu" + ] + }, + { + "capability_id": "penalized-glm-cv", + "label": "PenalizedGLM_CV", + "status": "canonical_current", + "source_ids": [ + "cv-benchmark-20260807-1347184c988d" + ] + }, + { + "capability_id": "coxph-cv", + "label": "CoxPHCV", + "status": "canonical_current", + "source_ids": [ + "cv-benchmark-20260807-1347184c988d" + ] + }, + { + "capability_id": "multiple-testing-resampling", + "label": "Multiple testing and resampling utilities", + "status": "benchmark_data_gap", + "source_ids": [], + "issue": "#109", + "disposition": "No current canonical utility-level statistical and timing matrix exists." + } ] } diff --git a/dev/benchmarks/benchmark_source_catalog.json b/dev/benchmarks/benchmark_source_catalog.json index b2fdd892c..4f9c6eca7 100644 --- a/dev/benchmarks/benchmark_source_catalog.json +++ b/dev/benchmarks/benchmark_source_catalog.json @@ -134,14 +134,27 @@ { "rule_id": "pr122-panel-stage-b-physical-validation", "priority": 20, - "path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", "classification": "not_canonical_ready", "canonical_eligible": false, "provenance_status": "validation_evidence", "timing_protocol_status": "not_applicable", "statistical_alignment_status": "accepted", "issue": "#93", - "reason": "Exact-head P100 Stage-B correctness/backend-provenance evidence for PR #122 is retained as the immutable raw artifact; its normalized SHA-protected canonical validation-only source is registered separately in frontend_sources.json." + "reason": "Immutable full Stage-B physical correctness/backend-provenance artifacts for PR #122 are retained for audit; only the currently SHA-protected normalized canonical source is registered in frontend_sources.json.", + "path_regex": "^results/pr122_p100/panel_stage_b_gpu_validation_.*[.]json$" + }, + { + "rule_id": "superseded-pr122-panel-stage-b-canonical-a57efcea", + "priority": 21, + "path": "results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809.json", + "classification": "superseded_or_duplicate", + "canonical_eligible": false, + "provenance_status": "complete", + "timing_protocol_status": "not_applicable", + "statistical_alignment_status": "accepted", + "superseded_by": "results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809_2701aa9f.json", + "issue": "#93", + "reason": "The 42-row a57efcea Stage-B canonical validation source is retained immutably for audit but is superseded by the exact-clean-head 2701aa9f P100 source that also physically validates an applicable Hausman branch." }, { "rule_id": "distribution-current-needs-audit", diff --git a/dev/benchmarks/frontend_sources.json b/dev/benchmarks/frontend_sources.json index 5d73fff74..ebaa06243 100644 --- a/dev/benchmarks/frontend_sources.json +++ b/dev/benchmarks/frontend_sources.json @@ -9,43 +9,100 @@ "host": "hz-4.matpool.com" }, "remote-p100-cv-20260807": { - "label": "Tesla P100 CV rerun — 2026-08-07", + "label": "Tesla P100 CV rerun \u2014 2026-08-07", "gpu": "Tesla P100-SXM2-16GB", "cpu": "x86_64", "host": "wE6lDe" }, "remote-p100-pr116-20260807": { - "label": "Tesla P100 PR #116 CV validation — 2026-08-07", + "label": "Tesla P100 PR #116 CV validation \u2014 2026-08-07", "gpu": "Tesla P100-SXM2-16GB", "cpu": "x86_64", "host": "wE6lDe" }, "remote-p100-pr122-20260809": { - "label": "Tesla P100 PR #122 Panel Stage B validation — 2026-08-09", + "label": "Tesla P100 PR #122 Panel Stage B validation \u2014 2026-08-09", "gpu": "Tesla P100-SXM2-16GB", "cpu": "x86_64" } }, "frameworks": { - "statgpu": {"display_name": "statgpu", "external": false, "backend_policy": "required"}, - "sklearn": {"display_name": "scikit-learn", "external": true, "backend_policy": "forbidden"}, - "scipy": {"display_name": "SciPy", "external": true, "backend_policy": "forbidden"}, - "statsmodels": {"display_name": "statsmodels", "external": true, "backend_policy": "forbidden"}, - "linearmodels": {"display_name": "linearmodels", "external": true, "backend_policy": "forbidden"}, - "pygam": {"display_name": "pyGAM", "external": true, "backend_policy": "forbidden"} + "statgpu": { + "display_name": "statgpu", + "external": false, + "backend_policy": "required" + }, + "sklearn": { + "display_name": "scikit-learn", + "external": true, + "backend_policy": "forbidden" + }, + "scipy": { + "display_name": "SciPy", + "external": true, + "backend_policy": "forbidden" + }, + "statsmodels": { + "display_name": "statsmodels", + "external": true, + "backend_policy": "forbidden" + }, + "linearmodels": { + "display_name": "linearmodels", + "external": true, + "backend_policy": "forbidden" + }, + "pygam": { + "display_name": "pyGAM", + "external": true, + "backend_policy": "forbidden" + } }, "comparisons": { - "penalized-glm-perf-20260622": {"label": "Penalized GLM performance — 2026-06-22", "env_id": "remote-p100"}, - "glm-solver-20260623": {"label": "GLM solver benchmark — 2026-06-23", "env_id": "remote-p100"}, - "coxph-efron-20260622": {"label": "CoxPH Efron benchmark — 2026-06-22", "env_id": "remote-p100"}, - "loss-functions-20260623": {"label": "Robust, quantile, and CoxPH loss benchmark — 2026-06-23", "env_id": "remote-p100"}, - "ordered-inference-pr74": {"label": "Ordered, penalized, bootstrap, and quantile inference — 2026-07-12", "env_id": "remote-p100"}, - "unsupervised-20260627": {"label": "Unsupervised benchmark — 2026-06-27", "env_id": "remote-p100"}, - "new-modules-20260624": {"label": "Panel, GAM, and ANOVA benchmark — 2026-06-24", "env_id": "remote-p100"}, - "p2-benchmark-20260617": {"label": "Covariance and nonparametric benchmark — 2026-06-17", "env_id": "remote-p100"}, - "cv-benchmark-20260807": {"label": "Cross-validation benchmark — 2026-08-07", "env_id": "remote-p100-cv-20260807"}, - "cv-benchmark-pr116-20260807": {"label": "Cross-validation benchmark after PR #116 repair — 2026-08-07", "env_id": "remote-p100-pr116-20260807"}, - "panel-stage-b-pr122-20260809": {"label": "Panel Stage B physical validation — PR #122 — 2026-08-09", "env_id": "remote-p100-pr122-20260809"} + "penalized-glm-perf-20260622": { + "label": "Penalized GLM performance \u2014 2026-06-22", + "env_id": "remote-p100" + }, + "glm-solver-20260623": { + "label": "GLM solver benchmark \u2014 2026-06-23", + "env_id": "remote-p100" + }, + "coxph-efron-20260622": { + "label": "CoxPH Efron benchmark \u2014 2026-06-22", + "env_id": "remote-p100" + }, + "loss-functions-20260623": { + "label": "Robust, quantile, and CoxPH loss benchmark \u2014 2026-06-23", + "env_id": "remote-p100" + }, + "ordered-inference-pr74": { + "label": "Ordered, penalized, bootstrap, and quantile inference \u2014 2026-07-12", + "env_id": "remote-p100" + }, + "unsupervised-20260627": { + "label": "Unsupervised benchmark \u2014 2026-06-27", + "env_id": "remote-p100" + }, + "new-modules-20260624": { + "label": "Panel, GAM, and ANOVA benchmark \u2014 2026-06-24", + "env_id": "remote-p100" + }, + "p2-benchmark-20260617": { + "label": "Covariance and nonparametric benchmark \u2014 2026-06-17", + "env_id": "remote-p100" + }, + "cv-benchmark-20260807": { + "label": "Cross-validation benchmark \u2014 2026-08-07", + "env_id": "remote-p100-cv-20260807" + }, + "cv-benchmark-pr116-20260807": { + "label": "Cross-validation benchmark after PR #116 repair \u2014 2026-08-07", + "env_id": "remote-p100-pr116-20260807" + }, + "panel-stage-b-pr122-20260809": { + "label": "Panel Stage B physical validation \u2014 PR #122 \u2014 2026-08-09", + "env_id": "remote-p100-pr122-20260809" + } }, "sources": [ { @@ -184,20 +241,20 @@ "provenance_note": "Physical PR #116 validation was executed on Tesla P100 from exact numerical implementation head e6e4846b06604ed53e65fc9afd9054bd5777098f. The artifact records that SHA directly; the historical pre-fix P100 source remains registered separately." }, { - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", "comparison_id": "panel-stage-b-pr122-20260809", - "path": "results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809.json", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9", + "path": "results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809_2701aa9f.json", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf", "parser": "panel_stage_b_physical_validation", "parser_version": "1.0", "env_id": "remote-p100-pr122-20260809", "required": true, "allowed_issue_codes": [], "source_date": "2026-08-09", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", - "raw_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", - "provenance_note": "Correctness/backend-provenance source only. Exact clean implementation head a57efcea29b0e87ecb89865c5a6902d5773812c6 passed both the full Stage-B P100 CuPy/Torch matrix and the focused disconnected two-way FE gate. Raw artifacts are results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json (Git blob 254b64776bff4e3b2b642bb4a2ae1eea25f4751c) and results/pr122_p100/panel_stage_b_disconnected_fe_gpu_validation_a57efcea.json (Git blob 3bda0b2040479ba8201e2722eb990ba086c3f3b9), committed by 72b3279d2028e8ec2af30e138e123aceb611ae8c. CuPy and Torch each passed all 17 estimator cases and four Hausman diagnostics in the full gate; the focused gate confirmed component-aware df_resid=1/effect_rank=7/incidence_components=3 and restored Torch confidence intervals to NumPy parity. No timing was collected." + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", + "raw_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", + "provenance_note": "Final PR #122 Stage-B correctness/backend-provenance source. Exact clean P100 measurement 2701aa9feb3796c33c94e6480fcb78c80c6a809c passed all 17 estimator cases and five Hausman diagnostics on each of CuPy and Torch, with requested/executed backend identity and no CPU fallback. The dedicated hausman_applicable_nonzero_effect fixture is applicable on both GPU backends with df=1 and statistic/p-value agreement versus NumPy at floating-point noise. Raw artifact results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json has Git blob fa3a253e6d882a4e69be29e7e3b1dce7b223b9a9 and was committed by 0d0d654d825cea872672f27d02107a58048b345f. The older focused disconnected-FE artifact results/pr122_p100/panel_stage_b_disconnected_fe_gpu_validation_a57efcea.json (Git blob 3bda0b2040479ba8201e2722eb990ba086c3f3b9, measurement a57efcea29b0e87ecb89865c5a6902d5773812c6) is retained only as supplementary evidence for the unchanged df=1 path. No timing was collected." } ] } diff --git a/dev/reviews/pr122_physical_gpu_validation.md b/dev/reviews/pr122_physical_gpu_validation.md index 9bbc377f4..b3e688142 100644 --- a/dev/reviews/pr122_physical_gpu_validation.md +++ b/dev/reviews/pr122_physical_gpu_validation.md @@ -1,147 +1,71 @@ # PR #122 Panel Stage B physical GPU validation -## Current acceptance status +## Physical acceptance status -**PARTIAL_REMOTE_PENDING**. +**PHYSICAL_GPU_ACCEPTED** for the Stage-B runner measured at exact clean implementation head `2701aa9feb3796c33c94e6480fcb78c80c6a809c`. -The previously accepted Panel Tier-1 Stage B numerical implementation `a57efcea29b0e87ecb89865c5a6902d5773812c6` remains useful historical physical evidence, but it is no longer sufficient for final PR #122 acceptance because `dev/benchmarks/validate_panel_stage_b_gpu.py` changed after that measurement. +This status covers the active physical correctness/backend-provenance gate only. Exact-final-head hosted CI and a fresh `.claude/skills/code-review.md` review remain lifecycle gates after evidence promotion; the physical runner itself must not change without another P100 rerun. -A Ready-for-review Codex pass identified a physical-coverage gap: all four Hausman diagnostics per CUDA backend in the `a57efcea...` artifact are structured `applicable = false` results because the fitted covariance difference is not positive semidefinite. Those results correctly validate applicability/reason parity against NumPy, but they do not execute an applicable Hausman statistic, p-value, and degrees-of-freedom path on either physical GPU backend. +## Accepted full P100 artifact -The review/fix loop therefore reopened the physical gate and returned PR #122 to Draft. - -## Current runner fix - -The current physical runner now contains a dedicated deterministic fitted FE/RE Hausman fixture with: - -- seed `20260810`; -- 12 entities and 4 observations per entity; -- one slope; -- nonzero entity-effect scale `0.005`; -- noise scale `0.1`; -- 48 observations total. - -On the hosted NumPy reference under the physical-like Python 3.9 / NumPy 1.24.2 / SciPy 1.10.1 stack, this fixture is stably applicable with: - -- Hausman df `1`; -- finite statistic and p-value; -- a positive FE-minus-RE diagnostic covariance margin greater than `1e-6`. +- path: `results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json` +- measurement SHA: `2701aa9feb3796c33c94e6480fcb78c80c6a809c` +- artifact repository commit: `0d0d654d825cea872672f27d02107a58048b345f` +- Git blob: `fa3a253e6d882a4e69be29e7e3b1dce7b223b9a9` +- schema version: 2 +- working tree clean: true +- top-level status: success +- GPU: Tesla P100-SXM2-16GB +- Python: 3.9.16 +- NumPy: 1.24.2 +- SciPy: 1.10.1 +- Torch: 2.0.0 +- timing collected: false -The runner now requires each requested physical backend to provide at least one diagnostic that simultaneously has: +For both CuPy and Torch, all 17 estimator cases passed with the requested backend actually executed and no CPU fallback. -- `status = "success"`; -- `applicable = true`; -- finite `statistic`; -- finite `pvalue`; -- finite positive `df`. +## Hausman branch coverage -For the dedicated applicable fixture the runner also checks requested/executed backend identity and compares FE/RE coefficients, FE/RE diagnostic covariance, Hausman statistic, p-value, and df against the NumPy reference. The original four structured-inapplicable Hausman parameterizations remain in the matrix, so the eventual physical run must cover both applicability branches rather than replacing one with the other. +Each backend passed five Hausman diagnostics: -Hosted regression coverage also locks the nonzero-effect fixture and verifies that the aggregate physical gate fails closed when every Hausman result is inapplicable or when an `applicable=true` payload omits statistic/p-value/df. +1. `hausman_balanced` — structured `applicable=false` / non-PSD covariance difference; +2. `hausman_explicit_re_constant_balanced` — structured `applicable=false`; +3. `hausman_unbalanced` — structured `applicable=false`; +4. `hausman_explicit_re_constant_unbalanced` — structured `applicable=false`; +5. `hausman_applicable_nonzero_effect` — **`applicable=true`**, df=1. -The targeted review gate passed under Python 3.9 with NumPy 1.24.2 and SciPy 1.10.1 before the focused runner/test fix was committed. +For the dedicated applicable fixture, CuPy recorded statistic `1.1965942530851057` and p-value `0.27400344142676447`; Torch recorded statistic `1.1965942530849238` and p-value `0.2740034414268009`; the NumPy reference is statistic `1.196594253085033`, p-value `0.274003441426779`, df=1. Maximum statistic differences are `7.26e-14` (CuPy) and `1.09e-13` (Torch), and all FE/RE coefficient/covariance differences are below `1e-12`. -## Historical raw evidence +The fixture uses seed 20260810, 12 entities, 4 observations per entity, one slope, entity-effect scale 0.005, and noise scale 0.1. Its NumPy FE-minus-RE diagnostic covariance margin is `4.6413153162319366e-05`, safely above the hosted stability guard. -The last accepted full Stage-B physical artifact is retained unchanged: +## Supplementary disconnected-FE evidence -- path: `results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json` -- Git blob: `254b64776bff4e3b2b642bb4a2ae1eea25f4751c` -- schema version: 2 -- measured implementation SHA: `a57efcea29b0e87ecb89865c5a6902d5773812c6` -- clean working tree: true -- overall status: success -- CuPy: 17/17 estimator cases, requested backend `cupy`, no fallback -- Torch: 17/17 estimator cases, requested backend `torch`, no fallback -- four Hausman diagnostics per backend, all matching NumPy as structured inapplicable results -- no timing or speedup measurement collected. - -The focused disconnected two-way FE artifact is also retained unchanged: +The focused disconnected two-way FE artifact remains valid supplementary evidence for an unchanged numerical path: - path: `results/pr122_p100/panel_stage_b_disconnected_fe_gpu_validation_a57efcea.json` +- measurement SHA: `a57efcea29b0e87ecb89865c5a6902d5773812c6` +- artifact repository commit: `72b3279d2028e8ec2af30e138e123aceb611ae8c` - Git blob: `3bda0b2040479ba8201e2722eb990ba086c3f3b9` -- measured implementation SHA: `a57efcea29b0e87ecb89865c5a6902d5773812c6` -- clean working tree: true -- `nobs = 9` -- legacy residual df `0` -- component-aware/public residual df `1` -- effect rank `7` -- `rank_x = 1` -- incidence components `3` -- CuPy and Torch requested/executed backend provenance verified -- corrected df=1 confidence intervals agree with NumPy to machine precision. - -These artifacts continue to establish the previously reviewed estimator, inference, disconnected-FE, and structured-inapplicability behavior. They do **not** establish the newly required applicable-Hausman physical branch. - -## Historical environment - -The `a57efcea...` artifacts report: - -- Tesla P100-SXM2-16GB; -- Python 3.9.16; -- statgpu 0.2.4; -- NumPy 1.24.2; -- SciPy 1.10.1; -- PyTorch 2.0.0. - -The raw artifact records the CuPy package metadata field as `null`, but physical CuPy execution is independently established by the per-case `executed_backend = "cupy"` checks. - -## Existing canonical frontend evidence - -The currently committed canonical source remains the historical `a57efcea...` measurement: - -- `results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809.json` -- SHA-256 `a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9` -- source id `panel-stage-b-pr122-20260809-a6e47b9dec9c` -- 42 validation-only rows. - -It remains an immutable description of that historical physical run, but it must not be treated as final acceptance for the current runner. After the new exact-clean-head P100 run succeeds, a new canonical source must replace it and the frontend generated assets/contracts must be regenerated. With the new applicable Hausman diagnostic, the expected Stage-B validation row count is 44: 17 estimator cases x 2 backends plus 5 Hausman diagnostics x 2 backends. - -The PR122 evidence promotion step is an explicit source-registration action rather than a separate automatic normalizer. The current parser contract therefore requires the future canonical source to preserve the dedicated applicable Hausman `statistic`, `pvalue`, and `df`; if any are missing or invalid, the emitted validation row fails closed instead of publishing a passing result. - -## Local review/fix closure - -The review/fix cycle was re-run against the changed and adjacent files under `.claude/skills/code-review.md`. Local fixes now cover: - -- a deterministic, nonzero-entity-effect, fitted Hausman-applicable physical fixture; -- per-backend fail-closed enforcement requiring a successful applicable Hausman statistic/p-value/df result; -- FE/RE coefficient and diagnostic-covariance comparison for the dedicated physical fixture; -- hosted physical-runner regression coverage under the Python 3.9 / NumPy 1.24.2 / SciPy 1.10.1 stack; -- a dedicated 48 x 1 frontend identity and method/variant separation for the new fixture; -- canonical numeric-evidence fail-closed parsing for statistic/pvalue/df; -- explicit execution of the new parser regression in the maintained Benchmark Frontend Python 3.9/3.11 matrix; -- EN/CN changelog synchronization marking the older 42-row source as historical rather than final acceptance. - -No further locally actionable CRITICAL, HIGH, or in-scope MEDIUM finding was identified in the final changed+adjacent review. Exact-head hosted CI must still pass before this local closure is treated as complete. - -## Required remote closure - -Final physical acceptance now requires a fresh exact-clean-head P100 execution of `dev/benchmarks/validate_panel_stage_b_gpu.py` on the final runner head, with both CuPy and Torch requested. - -The new artifact must demonstrate, for each backend: +- legacy residual df: 0 +- component-aware/public residual df: 1 +- effect rank: 7 +- incidence components: 3 +- CuPy/Torch confidence intervals agree with NumPy at floating-point noise. -1. requested backend equals executed backend with no silent fallback; -2. all 17 estimator cases remain successful against NumPy; -3. the four existing Hausman parameterizations retain their expected structured applicability behavior; -4. `hausman_applicable_nonzero_effect` is `applicable = true`; -5. its Hausman statistic, p-value, and df agree with NumPy within the runner tolerances; -6. its FE/RE coefficients and diagnostic covariance agree with NumPy within the runner tolerances; -7. the top-level run reports a clean working tree and exact expected SHA. +It is deliberately identified as historical supplementary evidence rather than relabeled as a `2701aa9feb3796c33c94e6480fcb78c80c6a809c` measurement. -After that run is accepted, the lifecycle must: +## Promoted canonical evidence -- commit the immutable raw result; -- promote a new canonical Stage-B source preserving statistic/pvalue/df for the dedicated applicable Hausman fixture; -- update source/coverage contracts for five Hausman diagnostics per backend and 44 validation rows; -- regenerate the six tracked frontend/docs JSON assets; -- rerun exact-final-head hosted CI; -- resolve the applicable-Hausman review thread with the new evidence; -- perform another fresh review under `.claude/skills/code-review.md` before returning the PR to Ready. +- canonical path: `results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809_2701aa9f.json` +- canonical SHA-256: `2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf` +- source id: `panel-stage-b-pr122-20260809-2056f836bfe2` +- validation rows: 44 = 17 estimator cases x 2 backends + 5 Hausman diagnostics x 2 backends +- timing/speedup: absent by contract -## Hard-exit conclusion +The parser requires the dedicated applicable row to preserve finite nonnegative statistic, p-value in [0,1], and positive df; missing or invalid numeric evidence fails closed. The older 42-row canonical source remains in the repository as explicitly superseded historical audit evidence and is no longer the registered source. -Local fix status: the current review finding and all locally discovered adjacent coverage/documentation findings are fixed in runner/test/parser/CI/docs code. Targeted local/hosted checks passed before the closure commit; exact-head full hosted CI remains required. +## Physical conclusion -Remote status: a fresh P100 CuPy/Torch artifact is required because the physical validation runner changed. +The P2 finding “Require an applicable Hausman case in the GPU gate” is physically closed. Both physical backends now exercise the applicable statistic/p-value/df path and the structured-inapplicable path without fallback. -**Hard exit: PARTIAL_REMOTE_PENDING.** +**Physical gate: ACCEPTED.** diff --git a/dev/tests/test_panel_stage_b_applicable_hausman_parser.py b/dev/tests/test_panel_stage_b_applicable_hausman_parser.py index ade408f60..0926c7b7e 100644 --- a/dev/tests/test_panel_stage_b_applicable_hausman_parser.py +++ b/dev/tests/test_panel_stage_b_applicable_hausman_parser.py @@ -11,7 +11,7 @@ REPO_ROOT / "results" / "benchmark_frontend_sources" - / "panel_stage_b_pr122_p100_20260809.json" + / "panel_stage_b_pr122_p100_20260809_2701aa9f.json" ) diff --git a/dev/tests/test_panel_stage_b_frontend_source.py b/dev/tests/test_panel_stage_b_frontend_source.py index 98a7a2e49..8e859c86d 100644 --- a/dev/tests/test_panel_stage_b_frontend_source.py +++ b/dev/tests/test_panel_stage_b_frontend_source.py @@ -13,13 +13,13 @@ REPO_ROOT / "results" / "benchmark_frontend_sources" - / "panel_stage_b_pr122_p100_20260809.json" + / "panel_stage_b_pr122_p100_20260809_2701aa9f.json" ) RAW_SOURCE_PATH = ( REPO_ROOT / "results" / "pr122_p100" - / "panel_stage_b_gpu_validation_a57efcea.json" + / "panel_stage_b_gpu_validation_2701aa9f.json" ) FOCUSED_SOURCE_PATH = ( REPO_ROOT @@ -27,12 +27,14 @@ / "pr122_p100" / "panel_stage_b_disconnected_fe_gpu_validation_a57efcea.json" ) -EXPECTED_SHA256 = "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" -RAW_EXPECTED_BLOB_SHA = "254b64776bff4e3b2b642bb4a2ae1eea25f4751c" +EXPECTED_SHA256 = "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" +RAW_EXPECTED_BLOB_SHA = "fa3a253e6d882a4e69be29e7e3b1dce7b223b9a9" FOCUSED_EXPECTED_BLOB_SHA = "3bda0b2040479ba8201e2722eb990ba086c3f3b9" -SOURCE_ID = "panel-stage-b-pr122-20260809-a6e47b9dec9c" -MEASUREMENT_SHA = "a57efcea29b0e87ecb89865c5a6902d5773812c6" -ARTIFACT_COMMIT = "72b3279d2028e8ec2af30e138e123aceb611ae8c" +SOURCE_ID = "panel-stage-b-pr122-20260809-2056f836bfe2" +MEASUREMENT_SHA = "2701aa9feb3796c33c94e6480fcb78c80c6a809c" +ARTIFACT_COMMIT = "0d0d654d825cea872672f27d02107a58048b345f" +FOCUSED_MEASUREMENT_SHA = "a57efcea29b0e87ecb89865c5a6902d5773812c6" +FOCUSED_ARTIFACT_COMMIT = "72b3279d2028e8ec2af30e138e123aceb611ae8c" ENV_ID = "remote-p100-pr122-20260809" @@ -62,8 +64,8 @@ def test_pr122_physical_source_contract_and_hash() -> None: assert data["backend_times"] == {"numpy": None, "cupy": None, "torch": None} assert data["compatibility_matrix"]["cupy"]["model_cases"] == "17/17" assert data["compatibility_matrix"]["torch"]["model_cases"] == "17/17" - assert data["compatibility_matrix"]["cupy"]["diagnostics"] == "4/4" - assert data["compatibility_matrix"]["torch"]["diagnostics"] == "4/4" + assert data["compatibility_matrix"]["cupy"]["diagnostics"] == "5/5" + assert data["compatibility_matrix"]["torch"]["diagnostics"] == "5/5" assert data["compatibility_matrix"]["cupy"]["cpu_fallback"] is False assert data["compatibility_matrix"]["torch"]["cpu_fallback"] is False assert data["compatibility_matrix"]["cupy"]["disconnected_fe"] == "pass" @@ -76,11 +78,11 @@ def test_pr122_physical_source_contract_and_hash() -> None: focused_meta = data["focused_artifact"] assert focused_meta["path"] == str(FOCUSED_SOURCE_PATH.relative_to(REPO_ROOT)) - assert focused_meta["repository_commit"] == ARTIFACT_COMMIT + assert focused_meta["repository_commit"] == FOCUSED_ARTIFACT_COMMIT assert focused_meta["git_blob_sha"] == FOCUSED_EXPECTED_BLOB_SHA assert focused_meta["status"] == "success" - assert focused["git_sha"] == MEASUREMENT_SHA + assert focused["git_sha"] == FOCUSED_MEASUREMENT_SHA assert focused["working_tree_clean"] is True assert focused["status"] == "success" assert focused["reference"]["legacy_df_resid"] == 0 @@ -92,6 +94,19 @@ def test_pr122_physical_source_contract_and_hash() -> None: assert focused["backend_results"]["cupy"]["status"] == "success" assert focused["backend_results"]["torch"]["status"] == "success" assert focused["backend_results"]["torch"]["differences_vs_numpy"]["conf_int"] < 1e-12 + for backend in ("cupy", "torch"): + diagnostic = data["backend_results"][backend]["diagnostics"][ + "hausman_applicable_nonzero_effect" + ] + assert diagnostic["status"] == "success" + assert diagnostic["applicable"] is True + assert diagnostic["reason"] is None + assert diagnostic["df"] == 1.0 + assert 0.0 <= diagnostic["pvalue"] <= 1.0 + assert diagnostic["statistic"] >= 0.0 + assert diagnostic["max_abs_differences"]["statistic"] < 2e-13 + assert diagnostic["max_abs_differences"]["pvalue"] < 5e-14 + assert data["environment"]["gpu"] == "Tesla P100-SXM2-16GB" assert data["environment"]["packages"]["cupy"] is None @@ -106,7 +121,7 @@ def test_pr122_parser_emits_validation_only_frontend_runs() -> None: ) assert warnings == [] - assert len(runs) == 42 + assert len(runs) == 44 assert len(models) == 6 assert {run["backend"] for run in runs} == {"cupy", "torch"} assert {model["model_id"] for model in models} == { @@ -126,9 +141,21 @@ def test_pr122_parser_emits_validation_only_frontend_runs() -> None: assert all(run["parameters"]["working_tree_clean"] is True for run in runs) hausman = [run for run in runs if run["parameters"].get("diagnostic") == "hausman"] - assert len(hausman) == 8 - assert all(run["parameters"]["applicable"] is False for run in hausman) + assert len(hausman) == 10 assert all("inference" not in run["metrics"] for run in hausman) + applicable = [ + run for run in hausman + if run["parameters"].get("diagnostic_fixture") == "nonzero-effect-applicable" + ] + assert len(applicable) == 2 + assert {run["backend"] for run in applicable} == {"cupy", "torch"} + assert all(run["parameters"]["applicable"] is True for run in applicable) + assert {run["parameters"]["df"] for run in applicable} == {1.0} + assert all(run["parameters"]["statistic"] >= 0.0 for run in applicable) + assert all(0.0 <= run["parameters"]["pvalue"] <= 1.0 for run in applicable) + structured_inapplicable = [run for run in hausman if run not in applicable] + assert len(structured_inapplicable) == 8 + assert all(run["parameters"]["applicable"] is False for run in structured_inapplicable) assert {run["parameters"]["parameterization"] for run in hausman} == { "standard", "re-explicit-constant", @@ -138,6 +165,7 @@ def test_pr122_parser_emits_validation_only_frontend_runs() -> None: "hausman-unbalanced", "hausman-re-explicit-constant-balanced", "hausman-re-explicit-constant-unbalanced", + "hausman-applicable-nonzero-effect", } estimator_runs = [run for run in runs if run not in hausman] diff --git a/docs/assets/benchmarks/data/benchmark_data.json b/docs/assets/benchmarks/data/benchmark_data.json index d82982f24..b7b025ba4 100644 --- a/docs/assets/benchmarks/data/benchmark_data.json +++ b/docs/assets/benchmarks/data/benchmark_data.json @@ -4,7 +4,7 @@ "meta": { "generator": "dev/benchmarks/generate_benchmark_data.py", "git_sha": "deterministic", - "generation_id": "b086cbafb6408c586ed6e0f22e72b058489450cbbe2b401cee1dfebdf61bbf88" + "generation_id": "b425b95947fcb5ee7dcd4e6e10f1b108cfe82b804f5d46428e63c1fb5ca35b1d" }, "environments": [ { @@ -91462,7 +91462,7 @@ "comparison_id": "cv-benchmark-pr116-20260807" }, { - "run_id": "6fbd213c0e98b871", + "run_id": "7279d751fec4ae72", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -91486,17 +91486,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -91524,18 +91524,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "5e656f753d05f842", + "run_id": "56290607cc2a0cf2", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -91559,17 +91559,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -91601,18 +91601,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "5e2fc37763eb7b2d", + "run_id": "695e9058534086b0", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -91636,17 +91636,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -91670,18 +91670,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "9f8fd6d0d61957ea", + "run_id": "477b4803cfaac953", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -91705,17 +91705,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -91739,18 +91739,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "71ea69c6370cd907", + "run_id": "6ca556cca3c1dc6c", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -91774,17 +91774,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -91812,18 +91812,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "98d002d67524d5a9", + "run_id": "e21809c952ed9df4", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -91847,17 +91847,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -91885,18 +91885,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "c39994c364cbb26b", + "run_id": "ac6d5fc5e070c379", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -91920,17 +91920,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -91958,18 +91958,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "0547ff5b87d20f6b", + "run_id": "d4465ae990d85c88", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -91993,17 +91993,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -92027,18 +92027,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "a2007b6e73b6a9f6", + "run_id": "e3be78f30afda49c", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -92062,17 +92062,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -92100,18 +92100,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "1b69538b7e275d2b", + "run_id": "4452fae4e283ef7b", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -92135,17 +92135,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -92173,18 +92173,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "c9d8ef5981103295", + "run_id": "056e0de8e3170092", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -92208,17 +92208,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -92250,18 +92250,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "1423e479796ac0a4", + "run_id": "a7069bd41b6ce3c2", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -92285,17 +92285,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -92319,18 +92319,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "d2b33efec229d231", + "run_id": "c4014db4618f0475", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -92354,17 +92354,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -92388,18 +92388,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "777bc6b6bb7506dc", + "run_id": "547f90cd8206fe0e", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -92423,17 +92423,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -92461,18 +92461,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "b6443da5a40e9b65", + "run_id": "3fc25da005609311", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -92496,17 +92496,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -92534,18 +92534,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "c018668fd1478bea", + "run_id": "445759ea0b44a878", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -92569,17 +92569,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -92607,18 +92607,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "d1a10fdc01d5978f", + "run_id": "6b0cbd5594989983", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -92642,17 +92642,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -92676,18 +92676,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "c00879787a568092", + "run_id": "83cf372c6fccda77", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -92714,17 +92714,17 @@ "diagnostic": "hausman", "parameterization": "standard", "applicable": false, - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -92740,13 +92740,13 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "cdf2bce987b76e0d", + "run_id": "095e3a18069cd015", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -92773,17 +92773,17 @@ "diagnostic": "hausman", "parameterization": "re-explicit-constant", "applicable": false, - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -92799,13 +92799,13 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "8a49ce80e42c9187", + "run_id": "a5ce2c8e73fdfcd3", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -92832,17 +92832,17 @@ "diagnostic": "hausman", "parameterization": "standard", "applicable": false, - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -92858,13 +92858,13 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "5a064e9cd732a439", + "run_id": "08bb5121ff32dd95", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -92891,17 +92891,17 @@ "diagnostic": "hausman", "parameterization": "re-explicit-constant", "applicable": false, - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -92917,13 +92917,80 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "b4b8ad4fdb357766", + "run_id": "a72370d3b5ccdeef", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-0571875762c64d2c", + "method_config_id": "method-d58d685666eb74d4", + "variant": "hausman-applicable-nonzero-effect", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n48_p1", + "n_samples": 48, + "n_features": 1, + "label": "48×1" + }, + "parameters": { + "metric_scope": "physical_validation", + "diagnostic": "hausman", + "parameterization": "standard", + "applicable": true, + "diagnostic_fixture": "nonzero-effect-applicable", + "statistic": 1.1965942530851057, + "pvalue": 0.27400344142676447, + "df": 1.0, + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", + "date": "2026-08-09", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "hausman_backend_consistency", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + }, + { + "metric": "hausman_applicable_statistic_pvalue_df", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260809" + }, + { + "run_id": "6cd624414dece5bf", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -92947,17 +93014,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -92985,18 +93052,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "cb98913de9c65567", + "run_id": "d515d6684ce4f746", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -93020,17 +93087,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -93062,18 +93129,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "229b94497b7daf39", + "run_id": "6ccea7600064931d", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -93097,17 +93164,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -93131,18 +93198,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "2d6ad17269f7590c", + "run_id": "d6e9e3dbe35b8b12", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -93166,17 +93233,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -93200,18 +93267,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "cd64e8c60f0d713a", + "run_id": "1704f2b8ba0d05c5", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -93235,17 +93302,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -93273,18 +93340,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "da676a3aae12e295", + "run_id": "547b8f511ea88b95", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -93308,17 +93375,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -93346,18 +93413,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "736e2e19a439d96e", + "run_id": "c3b0d6f5d6fdfd93", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -93381,17 +93448,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -93419,18 +93486,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "eedb70bdf33cbefa", + "run_id": "89b036b7f61372b0", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -93454,17 +93521,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -93488,18 +93555,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "e0df29b034722d9c", + "run_id": "75dadabb2c7d4a31", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -93523,17 +93590,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -93561,18 +93628,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "de108bf245552035", + "run_id": "99bb431cee9ad0b9", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -93596,17 +93663,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -93634,18 +93701,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "291d0fccf452e187", + "run_id": "4b1040cb15d08732", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -93669,17 +93736,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -93711,18 +93778,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "89061c2c3eb5a5ca", + "run_id": "3a94049592ef4a57", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -93746,17 +93813,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -93780,18 +93847,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "d5bed9c1d4672354", + "run_id": "40b888d3411cdbec", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -93815,17 +93882,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -93849,18 +93916,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "ae0bb5e1f6073301", + "run_id": "d102490eea35e9d7", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -93884,17 +93951,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -93922,18 +93989,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "2fa9c8fffed9c95e", + "run_id": "9ca6ae85a86d0dce", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -93957,17 +94024,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -93995,18 +94062,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "ce673d81fe94d27f", + "run_id": "fc273a5c73d0ecea", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -94030,17 +94097,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -94068,18 +94135,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "7f84d1c7e0c31439", + "run_id": "bd74d2455189bbd5", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -94103,17 +94170,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -94137,18 +94204,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "b494d36de68d069f", + "run_id": "cee85afecd82d8ee", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -94175,17 +94242,17 @@ "diagnostic": "hausman", "parameterization": "standard", "applicable": false, - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -94201,13 +94268,13 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "a12a554e89cac8e5", + "run_id": "4712fb5193e2fb7f", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -94234,17 +94301,17 @@ "diagnostic": "hausman", "parameterization": "re-explicit-constant", "applicable": false, - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -94260,13 +94327,13 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "0f0059bb0eb5389a", + "run_id": "b07fbe6ab06e9c8a", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -94293,17 +94360,17 @@ "diagnostic": "hausman", "parameterization": "standard", "applicable": false, - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -94319,13 +94386,13 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "cc11ab1d8748ba1e", + "run_id": "81049fac88841b43", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -94352,17 +94419,17 @@ "diagnostic": "hausman", "parameterization": "re-explicit-constant", "applicable": false, - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -94378,7 +94445,74 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260809" + }, + { + "run_id": "3fd46d0bebaa4152", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-0571875762c64d2c", + "method_config_id": "method-d58d685666eb74d4", + "variant": "hausman-applicable-nonzero-effect", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n48_p1", + "n_samples": 48, + "n_features": 1, + "label": "48×1" + }, + "parameters": { + "metric_scope": "physical_validation", + "diagnostic": "hausman", + "parameterization": "standard", + "applicable": true, + "diagnostic_fixture": "nonzero-effect-applicable", + "statistic": 1.1965942530849238, + "pvalue": 0.2740034414268009, + "df": 1.0, + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", + "date": "2026-08-09", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "hausman_backend_consistency", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + }, + { + "metric": "hausman_applicable_statistic_pvalue_df", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" diff --git a/docs/assets/benchmarks/data/parse_report.json b/docs/assets/benchmarks/data/parse_report.json index 27c026b1f..68a6a5657 100644 --- a/docs/assets/benchmarks/data/parse_report.json +++ b/docs/assets/benchmarks/data/parse_report.json @@ -3,8 +3,8 @@ "files_seen": 11, "files_parsed": 11, "files_skipped": 0, - "runs_generated": 1860, - "generation_id": "b086cbafb6408c586ed6e0f22e72b058489450cbbe2b401cee1dfebdf61bbf88", + "runs_generated": 1862, + "generation_id": "b425b95947fcb5ee7dcd4e6e10f1b108cfe82b804f5d46428e63c1fb5ca35b1d", "issues": [ { "source_id": "glm-solver-20260623-1b6197d94d88", diff --git a/docs/assets/benchmarks/data/source_inventory.json b/docs/assets/benchmarks/data/source_inventory.json index f1cfde585..efd33ae22 100644 --- a/docs/assets/benchmarks/data/source_inventory.json +++ b/docs/assets/benchmarks/data/source_inventory.json @@ -1,22 +1,22 @@ { "inventory_version": "2.0", "catalog_version": "2.0", - "catalog_digest": "da825a61685b0e54061c18e6602d368473965f232390f941673f9eb369f5a488", + "catalog_digest": "c9c6655a95d2347de0344a9431f75ec3b218c0b70a8c842719b2f5b8174bed54", "coverage_matrix_version": "1.0", - "coverage_matrix_digest": "e7744e86819e3876b76a14d62b2dbac9506df6b809535dda1b38e36f582839dd", - "discovered_json_artifacts": 93, - "classified_candidate_sources": 93, + "coverage_matrix_digest": "8ed8713f8ef977ad4b33eab83a33d65227e6e12a8a5179a0d7e6dea848a85a91", + "discovered_json_artifacts": 95, + "classified_candidate_sources": 95, "eligible_sources": 11, "registered_sources": 11, "available_registered_sources": 11, "parsed_registered_sources": 11, "eligible_unregistered_sources": 0, - "not_canonical_ready_sources": 43, + "not_canonical_ready_sources": 45, "historical_or_excluded_sources": 39, - "superseded_or_duplicate_sources": 9, + "superseded_or_duplicate_sources": 10, "unrelated_json_artifacts": 0, "unclassified_artifacts": 0, - "catalog_policy_digest": "a6c275db00cdc4819a443117eef58e0f8eff7c04b923721371ba4b1bdb713195", + "catalog_policy_digest": "c32b3e90a3b6f9694bfa6052c5e19629220f9266b59eef0a8d5dd62a3705e637", "catalog_entries": [ { "path": "results/bench_large_scale.json", @@ -832,10 +832,28 @@ "path": "results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809.json", "artifact_type": "json", "source_date": "2026-08-09", + "classification": "superseded_or_duplicate", + "canonical_eligible": false, + "registered": false, + "source_id": null, + "parser": null, + "parser_version": null, + "provenance_status": "complete", + "timing_protocol_status": "not_applicable", + "statistical_alignment_status": "accepted", + "reason": "The 42-row a57efcea Stage-B canonical validation source is retained immutably for audit but is superseded by the exact-clean-head 2701aa9f P100 source that also physically validates an applicable Hausman branch.", + "superseded_by": "results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809_2701aa9f.json", + "issue": "#93", + "rule_id": "superseded-pr122-panel-stage-b-canonical-a57efcea" + }, + { + "path": "results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809_2701aa9f.json", + "artifact_type": "json", + "source_date": "2026-08-09", "classification": "registered_canonical", "canonical_eligible": true, "registered": true, - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", "parser": "panel_stage_b_physical_validation", "parser_version": "1.0", "provenance_status": "complete", @@ -1260,23 +1278,41 @@ "issue": "#100", "rule_id": "undated-json" }, + { + "path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "artifact_type": "json", + "source_date": null, + "classification": "not_canonical_ready", + "canonical_eligible": false, + "registered": false, + "source_id": null, + "parser": null, + "parser_version": null, + "provenance_status": "validation_evidence", + "timing_protocol_status": "not_applicable", + "statistical_alignment_status": "accepted", + "reason": "Immutable full Stage-B physical correctness/backend-provenance artifacts for PR #122 are retained for audit; only the currently SHA-protected normalized canonical source is registered in frontend_sources.json.", + "superseded_by": null, + "issue": "#93", + "rule_id": "pr122-panel-stage-b-physical-validation" + }, { "path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", "artifact_type": "json", "source_date": null, - "classification": "historical_or_excluded", + "classification": "not_canonical_ready", "canonical_eligible": false, "registered": false, "source_id": null, "parser": null, "parser_version": null, - "provenance_status": "incomplete_date", - "timing_protocol_status": "unknown", - "statistical_alignment_status": "unknown", - "reason": "Artifact has no deterministically recoverable result date and is excluded pending explicit provenance review.", + "provenance_status": "validation_evidence", + "timing_protocol_status": "not_applicable", + "statistical_alignment_status": "accepted", + "reason": "Immutable full Stage-B physical correctness/backend-provenance artifacts for PR #122 are retained for audit; only the currently SHA-protected normalized canonical source is registered in frontend_sources.json.", "superseded_by": null, - "issue": "#100", - "rule_id": "undated-json" + "issue": "#93", + "rule_id": "pr122-panel-stage-b-physical-validation" }, { "path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", @@ -1291,7 +1327,7 @@ "provenance_status": "validation_evidence", "timing_protocol_status": "not_applicable", "statistical_alignment_status": "accepted", - "reason": "Exact-head P100 Stage-B correctness/backend-provenance evidence for PR #122 is retained as the immutable raw artifact; its normalized SHA-protected canonical validation-only source is registered separately in frontend_sources.json.", + "reason": "Immutable full Stage-B physical correctness/backend-provenance artifacts for PR #122 are retained for audit; only the currently SHA-protected normalized canonical source is registered in frontend_sources.json.", "superseded_by": null, "issue": "#93", "rule_id": "pr122-panel-stage-b-physical-validation" @@ -1699,5 +1735,5 @@ "current_evidence_not_canonical_ready": 2, "partial_canonical": 7 }, - "generation_id": "b086cbafb6408c586ed6e0f22e72b058489450cbbe2b401cee1dfebdf61bbf88" + "generation_id": "b425b95947fcb5ee7dcd4e6e10f1b108cfe82b804f5d46428e63c1fb5ca35b1d" } \ No newline at end of file diff --git a/docs/cn/changelog.md b/docs/cn/changelog.md index 68c76ffe3..098c4abb0 100644 --- a/docs/cn/changelog.md +++ b/docs/cn/changelog.md @@ -15,7 +15,7 @@ - `PooledOLS.fit()` 与 `FamaMacBeth.fit()` 的可选 `entity_ids` 只用于 Stage-B within/between fit statistics 和 panel BP-LM。Pooled HAC 稳定排序现在让 entity diagnostic metadata 与 X/y 使用完全相同的 permutation；formula missing-row filtering 也会在形成 diagnostics 前对齐 observation-level side arrays。 - 增加 analytic/fitted regression、维护中的 Python 3.9 + Torch 2.0 CPU parity，以及可执行的 `linearmodels==7.0` definition-alignment job。FirstDifference 的外部比较只在两边 transformed sample 定义一致的 panel 上执行；Stage B 不会为了 external gate 静默改变 Stage-A 对内部缺期采用 adjacent-observed-row differencing 的既有契约。 - 新增 `dev/benchmarks/validate_panel_stage_b_gpu.py` 作为 exact-head physical correctness/provenance gate。此前在数值实现 `a57efcea29b0e87ecb89865c5a6902d5773812c6` 上接受的 P100 artifact 继续作为不可变的历史证据保留：CuPy 与 Torch 各自通过全部 17 个 estimator case，requested/executed backend 一致且无 fallback；focused disconnected two-way FE artifact 也把 df=1 inference boundary 验证到机器精度。该运行中每个 backend 的 4 个 Hausman parameterization 都是正确的结构化 `applicable=false` case，因此它们验证了 applicability/reason parity，但没有在物理 GPU 上执行 applicable Hausman 的 statistic/p-value/df 路径。 -- Ready-for-review 审计因此重新打开 physical gate。当前 runner 新增一个确定性的 48-observation、one-slope、nonzero-entity-effect fitted FE/RE fixture；它在 hosted NumPy reference 上稳定为 Hausman applicable，并要求每个 CuPy/Torch 物理 backend 对 FE/RE coefficient、diagnostic covariance、Hausman statistic、p-value 和 df 与 NumPy 做一致性验证。历史 `panel_stage_b_pr122_p100_20260809.json` 继续作为此前运行的不可变 42-row 记录；PR #122 的最终接受现在要求新的 exact-head P100 run，随后生成新的 44-row canonical source 并刷新 frontend assets。当前 hard exit：`PARTIAL_REMOTE_PENDING`。 +- 重新打开的 physical gate 已在精确 clean measurement head `2701aa9feb3796c33c94e6480fcb78c80c6a809c` 上闭合：Tesla P100 的 CuPy 与 Torch 各自通过全部 17 个 estimator case 和 5 个 Hausman diagnostic，requested/executed backend 一致且没有 CPU fallback。新增的 48-observation nonzero-effect fixture 在两个 backend 上均为 `applicable=true`、df=1；Hausman statistic 相对 NumPy 的最大差异不超过 `1.10e-13`，p-value 不超过 `2.19e-14`。新的 44-row canonical validation source 保留该分支的 statistic/pvalue/df；旧的 42-row a57efcea source 继续作为历史审计证据保留。本次证据不包含 timing 或 speedup 声明。 关联：Issue #93 与 pull request #122。 diff --git a/docs/en/changelog.md b/docs/en/changelog.md index 94842900d..bba565eee 100644 --- a/docs/en/changelog.md +++ b/docs/en/changelog.md @@ -15,7 +15,7 @@ - Added optional `entity_ids` to `PooledOLS.fit()` and `FamaMacBeth.fit()` solely for Stage-B within/between fit statistics and the panel BP-LM path. Pooled HAC sorting now carries entity diagnostic metadata through the same stable permutation as X/y. Formula missing-row filtering aligns observation-level side arrays before diagnostics are formed. - Added analytic/fitted regressions, maintained Python 3.9 + Torch 2.0 CPU parity, and an executable `linearmodels==7.0` definition-alignment job. FirstDifference external comparison is restricted to panels where both implementations use the same transformed sample; Stage B does not silently redefine the Stage-A adjacent-observed-row differencing contract for internal time gaps. - Added `dev/benchmarks/validate_panel_stage_b_gpu.py` as the exact-head physical correctness/provenance gate. The previously accepted P100 artifacts at numerical implementation `a57efcea29b0e87ecb89865c5a6902d5773812c6` remain immutable historical evidence: CuPy and Torch each passed all 17 estimator cases with requested-backend provenance and no fallback, while the focused disconnected two-way FE artifact validated the df=1 inference boundary to machine precision. The four Hausman parameterizations per backend in that run were all correctly structured `applicable=false` cases, so they validate applicability/reason parity but do not physically exercise an applicable Hausman statistic/p-value/df path. -- A Ready-for-review audit reopened the physical gate for that coverage gap. The current runner adds a deterministic 48-observation, one-slope, nonzero-entity-effect fitted FE/RE fixture that is stably Hausman-applicable on the hosted NumPy reference and requires each CuPy/Torch physical backend to match FE/RE coefficients, diagnostic covariance, Hausman statistic, p-value, and df. The historical `panel_stage_b_pr122_p100_20260809.json` remains an immutable 42-row record of the earlier run; final PR #122 acceptance now requires a fresh exact-head P100 run followed by a new 44-row canonical source and regenerated frontend assets. Current hard exit: `PARTIAL_REMOTE_PENDING`. +- The reopened physical gate is now closed on exact clean measurement head `2701aa9feb3796c33c94e6480fcb78c80c6a809c`: Tesla P100 CuPy and Torch each passed all 17 estimator cases and all five Hausman diagnostics with requested/executed backend identity and no CPU fallback. The dedicated 48-observation nonzero-effect fixture is `applicable=true` on both backends with df=1; its Hausman statistic differs from NumPy by at most `1.10e-13` and p-value by at most `2.19e-14`. The promoted 44-row canonical validation source preserves statistic/pvalue/df for that branch, while the older 42-row a57efcea source remains historical audit evidence. No timing or speedup claim is made. Related: Issue #93 and pull request #122. diff --git a/frontend/public/data/benchmark_data.json b/frontend/public/data/benchmark_data.json index d82982f24..b7b025ba4 100644 --- a/frontend/public/data/benchmark_data.json +++ b/frontend/public/data/benchmark_data.json @@ -4,7 +4,7 @@ "meta": { "generator": "dev/benchmarks/generate_benchmark_data.py", "git_sha": "deterministic", - "generation_id": "b086cbafb6408c586ed6e0f22e72b058489450cbbe2b401cee1dfebdf61bbf88" + "generation_id": "b425b95947fcb5ee7dcd4e6e10f1b108cfe82b804f5d46428e63c1fb5ca35b1d" }, "environments": [ { @@ -91462,7 +91462,7 @@ "comparison_id": "cv-benchmark-pr116-20260807" }, { - "run_id": "6fbd213c0e98b871", + "run_id": "7279d751fec4ae72", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -91486,17 +91486,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -91524,18 +91524,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "5e656f753d05f842", + "run_id": "56290607cc2a0cf2", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -91559,17 +91559,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -91601,18 +91601,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "5e2fc37763eb7b2d", + "run_id": "695e9058534086b0", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -91636,17 +91636,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -91670,18 +91670,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "9f8fd6d0d61957ea", + "run_id": "477b4803cfaac953", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -91705,17 +91705,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -91739,18 +91739,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "71ea69c6370cd907", + "run_id": "6ca556cca3c1dc6c", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -91774,17 +91774,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -91812,18 +91812,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "98d002d67524d5a9", + "run_id": "e21809c952ed9df4", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -91847,17 +91847,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -91885,18 +91885,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "c39994c364cbb26b", + "run_id": "ac6d5fc5e070c379", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -91920,17 +91920,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -91958,18 +91958,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "0547ff5b87d20f6b", + "run_id": "d4465ae990d85c88", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -91993,17 +91993,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -92027,18 +92027,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "a2007b6e73b6a9f6", + "run_id": "e3be78f30afda49c", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -92062,17 +92062,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -92100,18 +92100,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "1b69538b7e275d2b", + "run_id": "4452fae4e283ef7b", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -92135,17 +92135,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -92173,18 +92173,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "c9d8ef5981103295", + "run_id": "056e0de8e3170092", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -92208,17 +92208,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -92250,18 +92250,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "1423e479796ac0a4", + "run_id": "a7069bd41b6ce3c2", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -92285,17 +92285,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -92319,18 +92319,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "d2b33efec229d231", + "run_id": "c4014db4618f0475", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -92354,17 +92354,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -92388,18 +92388,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "777bc6b6bb7506dc", + "run_id": "547f90cd8206fe0e", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -92423,17 +92423,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -92461,18 +92461,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "b6443da5a40e9b65", + "run_id": "3fc25da005609311", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -92496,17 +92496,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -92534,18 +92534,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "c018668fd1478bea", + "run_id": "445759ea0b44a878", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -92569,17 +92569,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -92607,18 +92607,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "d1a10fdc01d5978f", + "run_id": "6b0cbd5594989983", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -92642,17 +92642,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -92676,18 +92676,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "c00879787a568092", + "run_id": "83cf372c6fccda77", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -92714,17 +92714,17 @@ "diagnostic": "hausman", "parameterization": "standard", "applicable": false, - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -92740,13 +92740,13 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "cdf2bce987b76e0d", + "run_id": "095e3a18069cd015", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -92773,17 +92773,17 @@ "diagnostic": "hausman", "parameterization": "re-explicit-constant", "applicable": false, - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -92799,13 +92799,13 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "8a49ce80e42c9187", + "run_id": "a5ce2c8e73fdfcd3", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -92832,17 +92832,17 @@ "diagnostic": "hausman", "parameterization": "standard", "applicable": false, - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -92858,13 +92858,13 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "5a064e9cd732a439", + "run_id": "08bb5121ff32dd95", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -92891,17 +92891,17 @@ "diagnostic": "hausman", "parameterization": "re-explicit-constant", "applicable": false, - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -92917,13 +92917,80 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "b4b8ad4fdb357766", + "run_id": "a72370d3b5ccdeef", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-0571875762c64d2c", + "method_config_id": "method-d58d685666eb74d4", + "variant": "hausman-applicable-nonzero-effect", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n48_p1", + "n_samples": 48, + "n_features": 1, + "label": "48×1" + }, + "parameters": { + "metric_scope": "physical_validation", + "diagnostic": "hausman", + "parameterization": "standard", + "applicable": true, + "diagnostic_fixture": "nonzero-effect-applicable", + "statistic": 1.1965942530851057, + "pvalue": 0.27400344142676447, + "df": 1.0, + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", + "date": "2026-08-09", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "hausman_backend_consistency", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + }, + { + "metric": "hausman_applicable_statistic_pvalue_df", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260809" + }, + { + "run_id": "6cd624414dece5bf", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -92947,17 +93014,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -92985,18 +93052,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "cb98913de9c65567", + "run_id": "d515d6684ce4f746", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -93020,17 +93087,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -93062,18 +93129,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "229b94497b7daf39", + "run_id": "6ccea7600064931d", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -93097,17 +93164,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -93131,18 +93198,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "2d6ad17269f7590c", + "run_id": "d6e9e3dbe35b8b12", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -93166,17 +93233,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -93200,18 +93267,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "cd64e8c60f0d713a", + "run_id": "1704f2b8ba0d05c5", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -93235,17 +93302,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -93273,18 +93340,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "da676a3aae12e295", + "run_id": "547b8f511ea88b95", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -93308,17 +93375,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -93346,18 +93413,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "736e2e19a439d96e", + "run_id": "c3b0d6f5d6fdfd93", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -93381,17 +93448,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -93419,18 +93486,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "eedb70bdf33cbefa", + "run_id": "89b036b7f61372b0", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -93454,17 +93521,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -93488,18 +93555,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "e0df29b034722d9c", + "run_id": "75dadabb2c7d4a31", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -93523,17 +93590,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -93561,18 +93628,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "de108bf245552035", + "run_id": "99bb431cee9ad0b9", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -93596,17 +93663,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -93634,18 +93701,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "291d0fccf452e187", + "run_id": "4b1040cb15d08732", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -93669,17 +93736,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -93711,18 +93778,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "89061c2c3eb5a5ca", + "run_id": "3a94049592ef4a57", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -93746,17 +93813,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -93780,18 +93847,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "d5bed9c1d4672354", + "run_id": "40b888d3411cdbec", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -93815,17 +93882,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -93849,18 +93916,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "ae0bb5e1f6073301", + "run_id": "d102490eea35e9d7", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -93884,17 +93951,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -93922,18 +93989,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "2fa9c8fffed9c95e", + "run_id": "9ca6ae85a86d0dce", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -93957,17 +94024,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -93995,18 +94062,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "ce673d81fe94d27f", + "run_id": "fc273a5c73d0ecea", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -94030,17 +94097,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -94068,18 +94135,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "7f84d1c7e0c31439", + "run_id": "bd74d2455189bbd5", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -94103,17 +94170,17 @@ }, "parameters": { "metric_scope": "physical_validation", - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -94137,18 +94204,18 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" }, "inference": { "ok": true, "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "b494d36de68d069f", + "run_id": "cee85afecd82d8ee", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -94175,17 +94242,17 @@ "diagnostic": "hausman", "parameterization": "standard", "applicable": false, - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -94201,13 +94268,13 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "a12a554e89cac8e5", + "run_id": "4712fb5193e2fb7f", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -94234,17 +94301,17 @@ "diagnostic": "hausman", "parameterization": "re-explicit-constant", "applicable": false, - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -94260,13 +94327,13 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "0f0059bb0eb5389a", + "run_id": "b07fbe6ab06e9c8a", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -94293,17 +94360,17 @@ "diagnostic": "hausman", "parameterization": "standard", "applicable": false, - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -94319,13 +94386,13 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" }, { - "run_id": "cc11ab1d8748ba1e", + "run_id": "81049fac88841b43", "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", "env_id": "remote-p100-pr122-20260809", "category_ids": [ @@ -94352,17 +94419,17 @@ "diagnostic": "hausman", "parameterization": "re-explicit-constant", "applicable": false, - "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", "working_tree_clean": true }, "source": { - "file": "panel_stage_b_pr122_p100_20260809.json", + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", "date": "2026-08-09", "parser": "parse_panel_stage_b_physical_validation_v1", "parser_version": "1.0", - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", - "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", - "sha256": "a6e47b9dec9c35040d2715b573aa2a93b084d83c574078bdb430861f0a9aa9f9" + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" }, "metrics": { "validation": { @@ -94378,7 +94445,74 @@ } ], "quality": "reported", - "source_file": "panel_stage_b_pr122_p100_20260809.json" + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" + } + }, + "comparison_id": "panel-stage-b-pr122-20260809" + }, + { + "run_id": "3fd46d0bebaa4152", + "benchmark_session_id": "remote-p100-pr122-20260809-panel-stage-b-pr122", + "env_id": "remote-p100-pr122-20260809", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-0571875762c64d2c", + "method_config_id": "method-d58d685666eb74d4", + "variant": "hausman-applicable-nonzero-effect", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n48_p1", + "n_samples": 48, + "n_features": 1, + "label": "48×1" + }, + "parameters": { + "metric_scope": "physical_validation", + "diagnostic": "hausman", + "parameterization": "standard", + "applicable": true, + "diagnostic_fixture": "nonzero-effect-applicable", + "statistic": 1.1965942530849238, + "pvalue": 0.2740034414268009, + "df": 1.0, + "measurement_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json", + "date": "2026-08-09", + "parser": "parse_panel_stage_b_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", + "original_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "sha256": "2056f836bfe2a708b3131becca42dbba15e519762c8bafb582000b19f81120bf" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "hausman_backend_consistency", + "status": "pass" + }, + { + "metric": "backend_provenance", + "status": "pass" + }, + { + "metric": "hausman_applicable_statistic_pvalue_df", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_b_pr122_p100_20260809_2701aa9f.json" } }, "comparison_id": "panel-stage-b-pr122-20260809" diff --git a/frontend/public/data/parse_report.json b/frontend/public/data/parse_report.json index 27c026b1f..68a6a5657 100644 --- a/frontend/public/data/parse_report.json +++ b/frontend/public/data/parse_report.json @@ -3,8 +3,8 @@ "files_seen": 11, "files_parsed": 11, "files_skipped": 0, - "runs_generated": 1860, - "generation_id": "b086cbafb6408c586ed6e0f22e72b058489450cbbe2b401cee1dfebdf61bbf88", + "runs_generated": 1862, + "generation_id": "b425b95947fcb5ee7dcd4e6e10f1b108cfe82b804f5d46428e63c1fb5ca35b1d", "issues": [ { "source_id": "glm-solver-20260623-1b6197d94d88", diff --git a/frontend/public/data/source_inventory.json b/frontend/public/data/source_inventory.json index f1cfde585..efd33ae22 100644 --- a/frontend/public/data/source_inventory.json +++ b/frontend/public/data/source_inventory.json @@ -1,22 +1,22 @@ { "inventory_version": "2.0", "catalog_version": "2.0", - "catalog_digest": "da825a61685b0e54061c18e6602d368473965f232390f941673f9eb369f5a488", + "catalog_digest": "c9c6655a95d2347de0344a9431f75ec3b218c0b70a8c842719b2f5b8174bed54", "coverage_matrix_version": "1.0", - "coverage_matrix_digest": "e7744e86819e3876b76a14d62b2dbac9506df6b809535dda1b38e36f582839dd", - "discovered_json_artifacts": 93, - "classified_candidate_sources": 93, + "coverage_matrix_digest": "8ed8713f8ef977ad4b33eab83a33d65227e6e12a8a5179a0d7e6dea848a85a91", + "discovered_json_artifacts": 95, + "classified_candidate_sources": 95, "eligible_sources": 11, "registered_sources": 11, "available_registered_sources": 11, "parsed_registered_sources": 11, "eligible_unregistered_sources": 0, - "not_canonical_ready_sources": 43, + "not_canonical_ready_sources": 45, "historical_or_excluded_sources": 39, - "superseded_or_duplicate_sources": 9, + "superseded_or_duplicate_sources": 10, "unrelated_json_artifacts": 0, "unclassified_artifacts": 0, - "catalog_policy_digest": "a6c275db00cdc4819a443117eef58e0f8eff7c04b923721371ba4b1bdb713195", + "catalog_policy_digest": "c32b3e90a3b6f9694bfa6052c5e19629220f9266b59eef0a8d5dd62a3705e637", "catalog_entries": [ { "path": "results/bench_large_scale.json", @@ -832,10 +832,28 @@ "path": "results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809.json", "artifact_type": "json", "source_date": "2026-08-09", + "classification": "superseded_or_duplicate", + "canonical_eligible": false, + "registered": false, + "source_id": null, + "parser": null, + "parser_version": null, + "provenance_status": "complete", + "timing_protocol_status": "not_applicable", + "statistical_alignment_status": "accepted", + "reason": "The 42-row a57efcea Stage-B canonical validation source is retained immutably for audit but is superseded by the exact-clean-head 2701aa9f P100 source that also physically validates an applicable Hausman branch.", + "superseded_by": "results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809_2701aa9f.json", + "issue": "#93", + "rule_id": "superseded-pr122-panel-stage-b-canonical-a57efcea" + }, + { + "path": "results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809_2701aa9f.json", + "artifact_type": "json", + "source_date": "2026-08-09", "classification": "registered_canonical", "canonical_eligible": true, "registered": true, - "source_id": "panel-stage-b-pr122-20260809-a6e47b9dec9c", + "source_id": "panel-stage-b-pr122-20260809-2056f836bfe2", "parser": "panel_stage_b_physical_validation", "parser_version": "1.0", "provenance_status": "complete", @@ -1260,23 +1278,41 @@ "issue": "#100", "rule_id": "undated-json" }, + { + "path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "artifact_type": "json", + "source_date": null, + "classification": "not_canonical_ready", + "canonical_eligible": false, + "registered": false, + "source_id": null, + "parser": null, + "parser_version": null, + "provenance_status": "validation_evidence", + "timing_protocol_status": "not_applicable", + "statistical_alignment_status": "accepted", + "reason": "Immutable full Stage-B physical correctness/backend-provenance artifacts for PR #122 are retained for audit; only the currently SHA-protected normalized canonical source is registered in frontend_sources.json.", + "superseded_by": null, + "issue": "#93", + "rule_id": "pr122-panel-stage-b-physical-validation" + }, { "path": "results/pr122_p100/panel_stage_b_gpu_validation_a57efcea.json", "artifact_type": "json", "source_date": null, - "classification": "historical_or_excluded", + "classification": "not_canonical_ready", "canonical_eligible": false, "registered": false, "source_id": null, "parser": null, "parser_version": null, - "provenance_status": "incomplete_date", - "timing_protocol_status": "unknown", - "statistical_alignment_status": "unknown", - "reason": "Artifact has no deterministically recoverable result date and is excluded pending explicit provenance review.", + "provenance_status": "validation_evidence", + "timing_protocol_status": "not_applicable", + "statistical_alignment_status": "accepted", + "reason": "Immutable full Stage-B physical correctness/backend-provenance artifacts for PR #122 are retained for audit; only the currently SHA-protected normalized canonical source is registered in frontend_sources.json.", "superseded_by": null, - "issue": "#100", - "rule_id": "undated-json" + "issue": "#93", + "rule_id": "pr122-panel-stage-b-physical-validation" }, { "path": "results/pr122_p100/panel_stage_b_gpu_validation_faa95ce7.json", @@ -1291,7 +1327,7 @@ "provenance_status": "validation_evidence", "timing_protocol_status": "not_applicable", "statistical_alignment_status": "accepted", - "reason": "Exact-head P100 Stage-B correctness/backend-provenance evidence for PR #122 is retained as the immutable raw artifact; its normalized SHA-protected canonical validation-only source is registered separately in frontend_sources.json.", + "reason": "Immutable full Stage-B physical correctness/backend-provenance artifacts for PR #122 are retained for audit; only the currently SHA-protected normalized canonical source is registered in frontend_sources.json.", "superseded_by": null, "issue": "#93", "rule_id": "pr122-panel-stage-b-physical-validation" @@ -1699,5 +1735,5 @@ "current_evidence_not_canonical_ready": 2, "partial_canonical": 7 }, - "generation_id": "b086cbafb6408c586ed6e0f22e72b058489450cbbe2b401cee1dfebdf61bbf88" + "generation_id": "b425b95947fcb5ee7dcd4e6e10f1b108cfe82b804f5d46428e63c1fb5ca35b1d" } \ No newline at end of file diff --git a/results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809_2701aa9f.json b/results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809_2701aa9f.json new file mode 100644 index 000000000..8a38e5e94 --- /dev/null +++ b/results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809_2701aa9f.json @@ -0,0 +1,545 @@ +{ + "method": "Panel Tier-1 Stage B physical GPU validation", + "source_schema_version": "1.0", + "source_date": "2026-08-09", + "git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", + "working_tree_clean": true, + "status": "success", + "schema_status": "ok", + "raw_artifact": { + "path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "repository_commit": "0d0d654d825cea872672f27d02107a58048b345f", + "git_blob_sha": "fa3a253e6d882a4e69be29e7e3b1dce7b223b9a9", + "generated_at": "2026-08-09T14:06:57.406080Z", + "schema_version": 2 + }, + "focused_artifact": { + "path": "results/pr122_p100/panel_stage_b_disconnected_fe_gpu_validation_a57efcea.json", + "repository_commit": "72b3279d2028e8ec2af30e138e123aceb611ae8c", + "git_blob_sha": "3bda0b2040479ba8201e2722eb990ba086c3f3b9", + "generated_at": "2026-08-09T03:37:05.589811+00:00", + "schema_version": 1, + "validation": "panel_stage_b_disconnected_two_way_fe", + "status": "success", + "measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "role": "historical supplementary evidence for unchanged disconnected-FE numerical path" + }, + "environment": { + "env_id": "remote-p100-pr122-20260809", + "gpu": "Tesla P100-SXM2-16GB", + "cpu": "x86_64", + "platform": "Linux-3.10.0-1062.el7.x86_64-x86_64-with-glibc2.31", + "python": "3.9.16", + "packages": { + "statgpu": "0.2.4", + "numpy": "1.24.2", + "scipy": "1.10.1", + "cupy": null, + "torch": "2.0.0" + }, + "available_backends": [ + "cupy", + "torch" + ] + }, + "protocol": { + "runner": "dev/benchmarks/validate_panel_stage_b_gpu.py", + "focused_runner": "dev/benchmarks/validate_panel_stage_b_disconnected_fe_gpu.py", + "runner_schema_version": 2, + "focused_runner_schema_version": 1, + "reference_backend": "numpy", + "dtype": "float64", + "timing_collected": false, + "failure_policy": "fail_on_backend_mismatch_or_precision_regression", + "rtol": 5e-06, + "atol": 5e-07 + }, + "backend_times": { + "numpy": null, + "cupy": null, + "torch": null + }, + "external_baseline": { + "name": "statgpu NumPy reference", + "time": null, + "version": null + }, + "precision_vs_external": {}, + "convergence_status": {}, + "backend_precision": { + "cupy": "pass", + "torch": "pass" + }, + "compatibility_matrix": { + "cupy": { + "model_cases": "17/17", + "diagnostics": "5/5", + "executed_backend": "cupy", + "cpu_fallback": false, + "disconnected_fe": "pass" + }, + "torch": { + "model_cases": "17/17", + "diagnostics": "5/5", + "executed_backend": "torch", + "cpu_fallback": false, + "disconnected_fe": "pass" + } + }, + "inference_matrix": { + "status": "pass", + "fields": [ + "coef", + "bse", + "tvalues", + "pvalues", + "conf_int", + "nobs", + "df_resid" + ], + "reference": "statgpu NumPy", + "reported_precision": "Exact clean-head P100 Stage-B matrix passed validator tolerances on CuPy/Torch. The dedicated nonzero-effect Hausman fixture was applicable on both physical GPU backends with df=1 and statistic/p-value differences versus NumPy below 1.1e-13 and 2.2e-14, respectively. The historical focused disconnected two-way FE artifact remains supplementary evidence for the unchanged df_resid=1/effect_rank=7/incidence_components=3 inference boundary." + }, + "validation_tier": "remote-full", + "timing_scope": { + "collected": false, + "reason": "Correctness/backend-provenance validation only; no benchmark timing was measured." + }, + "reproducibility": { + "exact_git_sha": "2701aa9feb3796c33c94e6480fcb78c80c6a809c", + "working_tree_clean": true, + "runner": "dev/benchmarks/validate_panel_stage_b_gpu.py", + "focused_runner": "dev/benchmarks/validate_panel_stage_b_disconnected_fe_gpu.py", + "raw_artifact_path": "results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json", + "raw_artifact_git_blob_sha": "fa3a253e6d882a4e69be29e7e3b1dce7b223b9a9", + "repository_commit": "0d0d654d825cea872672f27d02107a58048b345f", + "focused_artifact_path": "results/pr122_p100/panel_stage_b_disconnected_fe_gpu_validation_a57efcea.json", + "focused_artifact_git_blob_sha": "3bda0b2040479ba8201e2722eb990ba086c3f3b9", + "focused_measurement_git_sha": "a57efcea29b0e87ecb89865c5a6902d5773812c6", + "focused_repository_commit": "72b3279d2028e8ec2af30e138e123aceb611ae8c" + }, + "uncovered_reasons": [ + "Performance timing was not collected by this correctness-only physical validation and must not be inferred from this source.", + "The four standard/explicit-RE-constant Hausman datasets remain structured inapplicable because their covariance differences are materially indefinite; a separate nonzero-effect fitted fixture physically exercises the applicable statistic/p-value/df branch on both GPU backends.", + "The runner could not resolve an installed CuPy distribution version through importlib.metadata, so the source records the CuPy package version as null while executed_backend='cupy' proves physical backend execution.", + "The focused disconnected-FE artifact was measured earlier at a57efcea and is retained only as supplementary validation evidence for an unchanged numerical path; it is not represented as a 2701aa9f measurement or expanded into timing rows." + ], + "case_catalog": [ + { + "case_id": "pooled_balanced", + "model_id": "PooledOLS", + "variant": "balanced", + "n_samples": 54, + "n_features": 2, + "checks": [ + "fit_statistics", + "bp_lm", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + }, + { + "case_id": "pooled_hac_unsorted_balanced", + "model_id": "PooledOLS", + "variant": "balanced-hac-unsorted", + "n_samples": 54, + "n_features": 2, + "checks": [ + "fit_statistics", + "bp_lm", + "diagnostic_covariance", + "stage_a_inference", + "metadata_sort_alignment", + "backend_provenance" + ] + }, + { + "case_id": "between_balanced", + "model_id": "BetweenOLS", + "variant": "balanced", + "n_samples": 54, + "n_features": 2, + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + }, + { + "case_id": "first_difference_balanced", + "model_id": "FirstDifferenceOLS", + "variant": "balanced", + "n_samples": 54, + "n_features": 2, + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + }, + { + "case_id": "panel_entity_balanced", + "model_id": "PanelOLS", + "variant": "entity-fe-balanced", + "n_samples": 54, + "n_features": 2, + "checks": [ + "fit_statistics", + "pooling_f", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + }, + { + "case_id": "random_effects_balanced", + "model_id": "RandomEffects", + "variant": "balanced", + "n_samples": 54, + "n_features": 2, + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "random_effects_diagnostic_contract", + "backend_provenance" + ] + }, + { + "case_id": "random_effects_explicit_constant_balanced", + "model_id": "RandomEffects", + "variant": "explicit-constant-balanced", + "n_samples": 54, + "n_features": 3, + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "random_effects_diagnostic_contract", + "backend_provenance" + ] + }, + { + "case_id": "fama_macbeth_balanced", + "model_id": "FamaMacBeth", + "variant": "balanced", + "n_samples": 54, + "n_features": 2, + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + }, + { + "case_id": "panel_two_way_balanced", + "model_id": "PanelOLS", + "variant": "two-way-fe-balanced", + "n_samples": 54, + "n_features": 2, + "checks": [ + "fit_statistics", + "pooling_f", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + }, + { + "case_id": "pooled_unbalanced", + "model_id": "PooledOLS", + "variant": "unbalanced", + "n_samples": 49, + "n_features": 2, + "checks": [ + "fit_statistics", + "bp_lm", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + }, + { + "case_id": "pooled_hac_unsorted_unbalanced", + "model_id": "PooledOLS", + "variant": "unbalanced-hac-unsorted", + "n_samples": 49, + "n_features": 2, + "checks": [ + "fit_statistics", + "bp_lm", + "diagnostic_covariance", + "stage_a_inference", + "metadata_sort_alignment", + "backend_provenance" + ] + }, + { + "case_id": "between_unbalanced", + "model_id": "BetweenOLS", + "variant": "unbalanced", + "n_samples": 49, + "n_features": 2, + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + }, + { + "case_id": "first_difference_unbalanced", + "model_id": "FirstDifferenceOLS", + "variant": "unbalanced", + "n_samples": 49, + "n_features": 2, + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + }, + { + "case_id": "panel_entity_unbalanced", + "model_id": "PanelOLS", + "variant": "entity-fe-unbalanced", + "n_samples": 49, + "n_features": 2, + "checks": [ + "fit_statistics", + "pooling_f", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + }, + { + "case_id": "random_effects_unbalanced", + "model_id": "RandomEffects", + "variant": "unbalanced", + "n_samples": 49, + "n_features": 2, + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "random_effects_diagnostic_contract", + "backend_provenance" + ] + }, + { + "case_id": "random_effects_explicit_constant_unbalanced", + "model_id": "RandomEffects", + "variant": "explicit-constant-unbalanced", + "n_samples": 49, + "n_features": 3, + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "random_effects_diagnostic_contract", + "backend_provenance" + ] + }, + { + "case_id": "fama_macbeth_unbalanced", + "model_id": "FamaMacBeth", + "variant": "unbalanced", + "n_samples": 49, + "n_features": 2, + "checks": [ + "fit_statistics", + "diagnostic_covariance", + "stage_a_inference", + "backend_provenance" + ] + } + ], + "backend_results": { + "cupy": { + "status": "success", + "executed_backend": "cupy", + "model_cases": { + "pooled_balanced": "success", + "pooled_hac_unsorted_balanced": "success", + "between_balanced": "success", + "first_difference_balanced": "success", + "panel_entity_balanced": "success", + "random_effects_balanced": "success", + "random_effects_explicit_constant_balanced": "success", + "fama_macbeth_balanced": "success", + "panel_two_way_balanced": "success", + "pooled_unbalanced": "success", + "pooled_hac_unsorted_unbalanced": "success", + "between_unbalanced": "success", + "first_difference_unbalanced": "success", + "panel_entity_unbalanced": "success", + "random_effects_unbalanced": "success", + "random_effects_explicit_constant_unbalanced": "success", + "fama_macbeth_unbalanced": "success" + }, + "diagnostics": { + "hausman_balanced": { + "status": "success", + "max_abs_differences": { + "statistic": 0.0, + "pvalue": 0.0 + }, + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_explicit_re_constant_balanced": { + "status": "success", + "max_abs_differences": { + "statistic": 0.0, + "pvalue": 0.0 + }, + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_unbalanced": { + "status": "success", + "max_abs_differences": { + "statistic": 0.0, + "pvalue": 0.0 + }, + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_explicit_re_constant_unbalanced": { + "status": "success", + "max_abs_differences": { + "statistic": 0.0, + "pvalue": 0.0 + }, + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_applicable_nonzero_effect": { + "status": "success", + "max_abs_differences": { + "statistic": 7.260858581048524e-14, + "pvalue": 1.454392162258955e-14 + }, + "fit_max_abs_differences": { + "fe_coef": 0.0, + "re_coef": 2.220446049250313e-16, + "fe_covariance": 0.0, + "re_covariance": 5.421010862427522e-20 + }, + "applicable": true, + "reason": null, + "statistic": 1.1965942530851057, + "pvalue": 0.27400344142676447, + "df": 1.0, + "reference_statistic": 1.196594253085033, + "reference_pvalue": 0.274003441426779, + "reference_df": 1.0, + "reference_variance_difference": 4.6413153162319366e-05, + "fixture": { + "seed": 20260810, + "n_entities": 12, + "n_times": 4, + "entity_effect_scale": 0.005, + "noise_scale": 0.1 + } + } + } + }, + "torch": { + "status": "success", + "executed_backend": "torch", + "model_cases": { + "pooled_balanced": "success", + "pooled_hac_unsorted_balanced": "success", + "between_balanced": "success", + "first_difference_balanced": "success", + "panel_entity_balanced": "success", + "random_effects_balanced": "success", + "random_effects_explicit_constant_balanced": "success", + "fama_macbeth_balanced": "success", + "panel_two_way_balanced": "success", + "pooled_unbalanced": "success", + "pooled_hac_unsorted_unbalanced": "success", + "between_unbalanced": "success", + "first_difference_unbalanced": "success", + "panel_entity_unbalanced": "success", + "random_effects_unbalanced": "success", + "random_effects_explicit_constant_unbalanced": "success", + "fama_macbeth_unbalanced": "success" + }, + "diagnostics": { + "hausman_balanced": { + "status": "success", + "max_abs_differences": { + "statistic": 0.0, + "pvalue": 0.0 + }, + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_explicit_re_constant_balanced": { + "status": "success", + "max_abs_differences": { + "statistic": 0.0, + "pvalue": 0.0 + }, + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_unbalanced": { + "status": "success", + "max_abs_differences": { + "statistic": 0.0, + "pvalue": 0.0 + }, + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_explicit_re_constant_unbalanced": { + "status": "success", + "max_abs_differences": { + "statistic": 0.0, + "pvalue": 0.0 + }, + "applicable": false, + "reason": "covariance difference is not positive semidefinite" + }, + "hausman_applicable_nonzero_effect": { + "status": "success", + "max_abs_differences": { + "statistic": 1.092459456231154e-13, + "pvalue": 2.1871393585115584e-14 + }, + "fit_max_abs_differences": { + "fe_coef": 0.0, + "re_coef": 3.3306690738754696e-16, + "fe_covariance": 0.0, + "re_covariance": 8.131516293641283e-20 + }, + "applicable": true, + "reason": null, + "statistic": 1.1965942530849238, + "pvalue": 0.2740034414268009, + "df": 1.0, + "reference_statistic": 1.196594253085033, + "reference_pvalue": 0.274003441426779, + "reference_df": 1.0, + "reference_variance_difference": 4.6413153162319366e-05, + "fixture": { + "seed": 20260810, + "n_entities": 12, + "n_times": 4, + "entity_effect_scale": 0.005, + "noise_scale": 0.1 + } + } + } + } + } +} From 09d1d676be5d38254ea0f704a69145c72ccae1a8 Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 22:41:20 +0800 Subject: [PATCH 163/165] ci: remove PR122 evidence promotion carrier --- .github/workflows/pr122-finalize-evidence.yml | 389 ------------------ 1 file changed, 389 deletions(-) delete mode 100644 .github/workflows/pr122-finalize-evidence.yml diff --git a/.github/workflows/pr122-finalize-evidence.yml b/.github/workflows/pr122-finalize-evidence.yml deleted file mode 100644 index 13a93048d..000000000 --- a/.github/workflows/pr122-finalize-evidence.yml +++ /dev/null @@ -1,389 +0,0 @@ -name: PR122 finalize physical evidence - -on: - push: - branches: [agent/panel-p1-stage-b-diagnostics] - paths: - - '.github/workflows/pr122-finalize-evidence.yml' - -permissions: - contents: write - -jobs: - finalize: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v4 - with: - fetch-depth: 0 - - uses: actions/setup-python@v5 - with: - python-version: '3.11' - - name: Install Python validation dependencies - run: python -m pip install -U pip pytest 'jsonschema[format]' - - name: Promote exact-head P100 evidence and contracts - run: | - python - <<'PY' - from __future__ import annotations - - import json - import math - import re - import subprocess - from copy import deepcopy - from pathlib import Path - - root = Path.cwd() - measurement_sha = '2701aa9feb3796c33c94e6480fcb78c80c6a809c' - artifact_commit = '0d0d654d825cea872672f27d02107a58048b345f' - historical_measurement_sha = 'a57efcea29b0e87ecb89865c5a6902d5773812c6' - historical_artifact_commit = '72b3279d2028e8ec2af30e138e123aceb611ae8c' - - raw_rel = 'results/pr122_p100/panel_stage_b_gpu_validation_2701aa9f.json' - focused_rel = 'results/pr122_p100/panel_stage_b_disconnected_fe_gpu_validation_a57efcea.json' - old_source_rel = 'results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809.json' - new_source_rel = 'results/benchmark_frontend_sources/panel_stage_b_pr122_p100_20260809_2701aa9f.json' - raw_path = root / raw_rel - focused_path = root / focused_rel - old_source_path = root / old_source_rel - new_source_path = root / new_source_rel - - raw = json.loads(raw_path.read_text(encoding='utf-8')) - focused = json.loads(focused_path.read_text(encoding='utf-8')) - old = json.loads(old_source_path.read_text(encoding='utf-8')) - - assert raw['schema_version'] == 2 - assert raw['git_sha'] == measurement_sha - assert raw['working_tree_clean'] is True - assert raw['status'] == 'success' - assert raw['environment']['gpu'] == 'Tesla P100-SXM2-16GB' - assert raw['environment']['python'] == '3.9.16' - assert raw['environment']['packages']['numpy'] == '1.24.2' - assert raw['environment']['packages']['scipy'] == '1.10.1' - assert raw['environment']['packages']['torch'] == '2.0.0' - - expected_diagnostics = { - 'hausman_balanced', - 'hausman_explicit_re_constant_balanced', - 'hausman_unbalanced', - 'hausman_explicit_re_constant_unbalanced', - 'hausman_applicable_nonzero_effect', - } - for backend in ('cupy', 'torch'): - backend_raw = raw['backends'][backend] - models = backend_raw['models'] - assert len(models) == 17 - assert all(case['status'] == 'success' for case in models.values()) - assert all(case['executed_backend'] == backend for case in models.values()) - diagnostics = backend_raw['diagnostics'] - assert set(diagnostics) == expected_diagnostics - for diagnostic_id in expected_diagnostics - {'hausman_applicable_nonzero_effect'}: - diagnostic = diagnostics[diagnostic_id] - assert diagnostic['status'] == 'success' - assert diagnostic['applicable'] is False - assert diagnostic['reason'] == 'covariance difference is not positive semidefinite' - applicable = diagnostics['hausman_applicable_nonzero_effect'] - assert applicable['status'] == 'success' - assert applicable['applicable'] is True - assert applicable['reason'] is None - assert math.isfinite(float(applicable['statistic'])) - assert math.isfinite(float(applicable['pvalue'])) - assert float(applicable['df']) == 1.0 - assert float(applicable['max_abs_differences']['statistic']) < 2e-13 - assert float(applicable['max_abs_differences']['pvalue']) < 5e-14 - assert max(float(v) for v in applicable['fit_max_abs_differences'].values()) < 1e-12 - assert float(applicable['reference_variance_difference']) > 1e-6 - - raw_blob = subprocess.check_output(['git', 'hash-object', raw_rel], text=True).strip() - focused_blob = subprocess.check_output(['git', 'hash-object', focused_rel], text=True).strip() - assert raw_blob == 'fa3a253e6d882a4e69be29e7e3b1dce7b223b9a9' - assert focused_blob == '3bda0b2040479ba8201e2722eb990ba086c3f3b9' - assert focused['git_sha'] == historical_measurement_sha - assert focused['working_tree_clean'] is True - assert focused['status'] == 'success' - - promoted = deepcopy(old) - promoted['source_date'] = '2026-08-09' - promoted['git_sha'] = measurement_sha - promoted['working_tree_clean'] = True - promoted['status'] = 'success' - promoted['schema_status'] = 'ok' - promoted['raw_artifact'] = { - 'path': raw_rel, - 'repository_commit': artifact_commit, - 'git_blob_sha': raw_blob, - 'generated_at': raw['generated_at'], - 'schema_version': raw['schema_version'], - } - promoted['focused_artifact'] = { - 'path': focused_rel, - 'repository_commit': historical_artifact_commit, - 'git_blob_sha': focused_blob, - 'generated_at': focused.get('generated_at'), - 'schema_version': focused['schema_version'], - 'validation': 'panel_stage_b_disconnected_two_way_fe', - 'status': focused['status'], - 'measurement_git_sha': historical_measurement_sha, - 'role': 'historical supplementary evidence for unchanged disconnected-FE numerical path', - } - promoted['environment']['gpu'] = raw['environment']['gpu'] - promoted['environment']['platform'] = raw['environment']['platform'] - promoted['environment']['python'] = raw['environment']['python'] - promoted['environment']['packages'] = deepcopy(raw['environment']['packages']) - promoted['protocol']['runner_schema_version'] = raw['schema_version'] - promoted['protocol']['rtol'] = raw['tolerances']['rtol'] - promoted['protocol']['atol'] = raw['tolerances']['atol'] - promoted['backend_precision'] = {'cupy': 'pass', 'torch': 'pass'} - for backend in ('cupy', 'torch'): - promoted['compatibility_matrix'][backend]['model_cases'] = '17/17' - promoted['compatibility_matrix'][backend]['diagnostics'] = '5/5' - promoted['compatibility_matrix'][backend]['executed_backend'] = backend - promoted['compatibility_matrix'][backend]['cpu_fallback'] = False - promoted['compatibility_matrix'][backend]['disconnected_fe'] = 'pass' - promoted['inference_matrix']['status'] = 'pass' - promoted['inference_matrix']['reported_precision'] = ( - 'Exact clean-head P100 Stage-B matrix passed validator tolerances on CuPy/Torch. ' - 'The dedicated nonzero-effect Hausman fixture was applicable on both physical GPU backends ' - 'with df=1 and statistic/p-value differences versus NumPy below 1.1e-13 and 2.2e-14, respectively. ' - 'The historical focused disconnected two-way FE artifact remains supplementary evidence for the ' - 'unchanged df_resid=1/effect_rank=7/incidence_components=3 inference boundary.' - ) - promoted['validation_tier'] = 'remote-full' - promoted['timing_scope'] = { - 'collected': False, - 'reason': 'Correctness/backend-provenance validation only; no benchmark timing was measured.', - } - promoted['reproducibility'] = { - 'exact_git_sha': measurement_sha, - 'working_tree_clean': True, - 'runner': 'dev/benchmarks/validate_panel_stage_b_gpu.py', - 'focused_runner': 'dev/benchmarks/validate_panel_stage_b_disconnected_fe_gpu.py', - 'raw_artifact_path': raw_rel, - 'raw_artifact_git_blob_sha': raw_blob, - 'repository_commit': artifact_commit, - 'focused_artifact_path': focused_rel, - 'focused_artifact_git_blob_sha': focused_blob, - 'focused_measurement_git_sha': historical_measurement_sha, - 'focused_repository_commit': historical_artifact_commit, - } - promoted['uncovered_reasons'] = [ - 'Performance timing was not collected by this correctness-only physical validation and must not be inferred from this source.', - 'The four standard/explicit-RE-constant Hausman datasets remain structured inapplicable because their covariance differences are materially indefinite; a separate nonzero-effect fitted fixture physically exercises the applicable statistic/p-value/df branch on both GPU backends.', - "The runner could not resolve an installed CuPy distribution version through importlib.metadata, so the source records the CuPy package version as null while executed_backend='cupy' proves physical backend execution.", - 'The focused disconnected-FE artifact was measured earlier at a57efcea and is retained only as supplementary validation evidence for an unchanged numerical path; it is not represented as a 2701aa9f measurement or expanded into timing rows.', - ] - promoted['backend_results'] = {} - for backend in ('cupy', 'torch'): - backend_raw = raw['backends'][backend] - promoted['backend_results'][backend] = { - 'status': 'success', - 'executed_backend': backend, - 'model_cases': { - case_id: case['status'] for case_id, case in backend_raw['models'].items() - }, - 'diagnostics': deepcopy(backend_raw['diagnostics']), - } - - new_source_path.write_text( - json.dumps(promoted, indent=2, ensure_ascii=False) + '\n', encoding='utf-8' - ) - - from dev.benchmarks.frontend_data.canonical import source_sha256 - promoted_sha256 = source_sha256(new_source_path) - source_id = f'panel-stage-b-pr122-20260809-{promoted_sha256[:12]}' - - manifest_path = root / 'dev/benchmarks/frontend_sources.json' - manifest = json.loads(manifest_path.read_text(encoding='utf-8')) - entries = [ - entry for entry in manifest['sources'] - if entry.get('comparison_id') == 'panel-stage-b-pr122-20260809' - ] - assert len(entries) == 1 - entry = entries[0] - entry.update({ - 'source_id': source_id, - 'path': new_source_rel, - 'original_path': raw_rel, - 'sha256': promoted_sha256, - 'parser': 'panel_stage_b_physical_validation', - 'parser_version': '1.0', - 'env_id': 'remote-p100-pr122-20260809', - 'required': True, - 'allowed_issue_codes': [], - 'source_date': '2026-08-09', - 'measurement_git_sha': measurement_sha, - 'raw_git_sha': measurement_sha, - 'provenance_note': ( - 'Final PR #122 Stage-B correctness/backend-provenance source. Exact clean P100 measurement ' - f'{measurement_sha} passed all 17 estimator cases and five Hausman diagnostics on each of CuPy and Torch, ' - 'with requested/executed backend identity and no CPU fallback. The dedicated ' - 'hausman_applicable_nonzero_effect fixture is applicable on both GPU backends with df=1 and ' - 'statistic/p-value agreement versus NumPy at floating-point noise. Raw artifact ' - f'{raw_rel} has Git blob {raw_blob} and was committed by {artifact_commit}. ' - f'The older focused disconnected-FE artifact {focused_rel} (Git blob {focused_blob}, ' - f'measurement {historical_measurement_sha}) is retained only as supplementary evidence for the unchanged df=1 path. ' - 'No timing was collected.' - ), - }) - manifest_path.write_text(json.dumps(manifest, indent=2) + '\n', encoding='utf-8') - - coverage_path = root / 'dev/benchmarks/benchmark_coverage_matrix.json' - coverage = json.loads(coverage_path.read_text(encoding='utf-8')) - panel_rows = [c for c in coverage['capabilities'] if c['capability_id'] == 'panel-estimation'] - assert len(panel_rows) == 1 - panel_row = panel_rows[0] - panel_row['source_ids'] = [ - source_id if sid.startswith('panel-stage-b-pr122-20260809-') else sid - for sid in panel_row['source_ids'] - ] - panel_row['disposition'] = ( - 'June timing rows cover aligned PanelOLS and RandomEffects. PR #122 adds canonical validation-only ' - 'CuPy/Torch evidence for the 17-case Stage-B estimator matrix, five Hausman diagnostics per backend ' - '(including a physically applicable nonzero-effect statistic/p-value/df path), backend provenance, ' - 'Stage-A inference regression, and the disconnected two-way FE df=1 physical boundary; broader ' - 'performance/covariance timing remains open.' - ) - coverage_path.write_text(json.dumps(coverage, indent=2) + '\n', encoding='utf-8') - - catalog_path = root / 'dev/benchmarks/benchmark_source_catalog.json' - catalog = json.loads(catalog_path.read_text(encoding='utf-8')) - raw_rules = [r for r in catalog['rules'] if r['rule_id'] == 'pr122-panel-stage-b-physical-validation'] - assert len(raw_rules) == 1 - raw_rule = raw_rules[0] - raw_rule.pop('path', None) - raw_rule['path_regex'] = r'^results/pr122_p100/panel_stage_b_gpu_validation_.*[.]json$' - raw_rule['reason'] = ( - 'Immutable full Stage-B physical correctness/backend-provenance artifacts for PR #122 are retained ' - 'for audit; only the currently SHA-protected normalized canonical source is registered in frontend_sources.json.' - ) - historical_rule_id = 'superseded-pr122-panel-stage-b-canonical-a57efcea' - if not any(r['rule_id'] == historical_rule_id for r in catalog['rules']): - insert_at = catalog['rules'].index(raw_rule) + 1 - catalog['rules'].insert(insert_at, { - 'rule_id': historical_rule_id, - 'priority': 21, - 'path': old_source_rel, - 'classification': 'superseded_or_duplicate', - 'canonical_eligible': False, - 'provenance_status': 'complete', - 'timing_protocol_status': 'not_applicable', - 'statistical_alignment_status': 'accepted', - 'superseded_by': new_source_rel, - 'issue': '#93', - 'reason': ( - 'The 42-row a57efcea Stage-B canonical validation source is retained immutably for audit but ' - 'is superseded by the exact-clean-head 2701aa9f P100 source that also physically validates an applicable Hausman branch.' - ), - }) - catalog_path.write_text(json.dumps(catalog, indent=2) + '\n', encoding='utf-8') - - test_path = root / 'dev/tests/test_panel_stage_b_frontend_source.py' - text = test_path.read_text(encoding='utf-8') - text = text.replace('panel_stage_b_pr122_p100_20260809.json', 'panel_stage_b_pr122_p100_20260809_2701aa9f.json') - text = text.replace('panel_stage_b_gpu_validation_a57efcea.json', 'panel_stage_b_gpu_validation_2701aa9f.json') - text = re.sub(r'EXPECTED_SHA256 = "[0-9a-f]+"', f'EXPECTED_SHA256 = "{promoted_sha256}"', text) - text = re.sub(r'RAW_EXPECTED_BLOB_SHA = "[0-9a-f]+"', f'RAW_EXPECTED_BLOB_SHA = "{raw_blob}"', text) - text = re.sub(r'SOURCE_ID = "[^"]+"', f'SOURCE_ID = "{source_id}"', text) - text = re.sub(r'MEASUREMENT_SHA = "[0-9a-f]+"', f'MEASUREMENT_SHA = "{measurement_sha}"', text) - text = re.sub( - r'ARTIFACT_COMMIT = "[0-9a-f]+"', - f'ARTIFACT_COMMIT = "{artifact_commit}"\nFOCUSED_MEASUREMENT_SHA = "{historical_measurement_sha}"\nFOCUSED_ARTIFACT_COMMIT = "{historical_artifact_commit}"', - text, - count=1, - ) - text = text.replace('assert data["compatibility_matrix"]["cupy"]["diagnostics"] == "4/4"', 'assert data["compatibility_matrix"]["cupy"]["diagnostics"] == "5/5"') - text = text.replace('assert data["compatibility_matrix"]["torch"]["diagnostics"] == "4/4"', 'assert data["compatibility_matrix"]["torch"]["diagnostics"] == "5/5"') - text = text.replace('assert focused_meta["repository_commit"] == ARTIFACT_COMMIT', 'assert focused_meta["repository_commit"] == FOCUSED_ARTIFACT_COMMIT') - text = text.replace('assert focused["git_sha"] == MEASUREMENT_SHA', 'assert focused["git_sha"] == FOCUSED_MEASUREMENT_SHA') - marker = ' assert data["environment"]["gpu"] == "Tesla P100-SXM2-16GB"\n' - assert marker in text - diagnostic_contract = ''' for backend in ("cupy", "torch"):\n diagnostic = data["backend_results"][backend]["diagnostics"][\n "hausman_applicable_nonzero_effect"\n ]\n assert diagnostic["status"] == "success"\n assert diagnostic["applicable"] is True\n assert diagnostic["reason"] is None\n assert diagnostic["df"] == 1.0\n assert 0.0 <= diagnostic["pvalue"] <= 1.0\n assert diagnostic["statistic"] >= 0.0\n assert diagnostic["max_abs_differences"]["statistic"] < 2e-13\n assert diagnostic["max_abs_differences"]["pvalue"] < 5e-14\n\n''' - text = text.replace(marker, diagnostic_contract + marker, 1) - - new_parser_test = '''def test_pr122_parser_emits_validation_only_frontend_runs() -> None:\n from dev.benchmarks.frontend_data.parsers import (\n parse_panel_stage_b_physical_validation,\n )\n\n runs, models, warnings = parse_panel_stage_b_physical_validation(\n SOURCE_PATH, ENV_ID\n )\n\n assert warnings == []\n assert len(runs) == 44\n assert len(models) == 6\n assert {run["backend"] for run in runs} == {"cupy", "torch"}\n assert {model["model_id"] for model in models} == {\n "PooledOLS",\n "BetweenOLS",\n "FirstDifferenceOLS",\n "PanelOLS",\n "RandomEffects",\n "FamaMacBeth",\n }\n assert all("timing" not in run["metrics"] for run in runs)\n assert all("speedup" not in run["metrics"] for run in runs)\n assert all(run["metrics"]["validation"]["status"] == "pass" for run in runs)\n assert all(\n run["parameters"]["measurement_git_sha"] == MEASUREMENT_SHA for run in runs\n )\n assert all(run["parameters"]["working_tree_clean"] is True for run in runs)\n\n hausman = [run for run in runs if run["parameters"].get("diagnostic") == "hausman"]\n assert len(hausman) == 10\n assert all("inference" not in run["metrics"] for run in hausman)\n applicable = [\n run for run in hausman\n if run["parameters"].get("diagnostic_fixture") == "nonzero-effect-applicable"\n ]\n assert len(applicable) == 2\n assert {run["backend"] for run in applicable} == {"cupy", "torch"}\n assert all(run["parameters"]["applicable"] is True for run in applicable)\n assert {run["parameters"]["df"] for run in applicable} == {1.0}\n assert all(run["parameters"]["statistic"] >= 0.0 for run in applicable)\n assert all(0.0 <= run["parameters"]["pvalue"] <= 1.0 for run in applicable)\n structured_inapplicable = [run for run in hausman if run not in applicable]\n assert len(structured_inapplicable) == 8\n assert all(run["parameters"]["applicable"] is False for run in structured_inapplicable)\n assert {run["parameters"]["parameterization"] for run in hausman} == {\n "standard",\n "re-explicit-constant",\n }\n assert {run["variant"] for run in hausman} == {\n "hausman-balanced",\n "hausman-unbalanced",\n "hausman-re-explicit-constant-balanced",\n "hausman-re-explicit-constant-unbalanced",\n "hausman-applicable-nonzero-effect",\n }\n\n estimator_runs = [run for run in runs if run not in hausman]\n assert len(estimator_runs) == 34\n assert all(run["metrics"]["inference"]["ok"] is True for run in estimator_runs)\n\n explicit_re = [\n run\n for run in estimator_runs\n if run["model_id"] == "RandomEffects"\n and run["variant"].startswith("explicit-constant-")\n ]\n assert len(explicit_re) == 4\n assert {run["scale"]["n_features"] for run in explicit_re} == {3}\n\n''' - text, count = re.subn( - r'def test_pr122_parser_emits_validation_only_frontend_runs\(\) -> None:\n.*?(?=\ndef test_pr122_parser_is_registered_in_manifest)', - new_parser_test, - text, - flags=re.S, - ) - assert count == 1 - test_path.write_text(text, encoding='utf-8') - - applicable_test_path = root / 'dev/tests/test_panel_stage_b_applicable_hausman_parser.py' - applicable_text = applicable_test_path.read_text(encoding='utf-8') - applicable_text = applicable_text.replace( - 'panel_stage_b_pr122_p100_20260809.json', - 'panel_stage_b_pr122_p100_20260809_2701aa9f.json', - ) - applicable_test_path.write_text(applicable_text, encoding='utf-8') - - en_path = root / 'docs/en/changelog.md' - en_lines = en_path.read_text(encoding='utf-8').splitlines() - en_idx = [i for i, line in enumerate(en_lines) if line.startswith('- A Ready-for-review audit reopened the physical gate')] - assert len(en_idx) == 1 - en_lines[en_idx[0]] = ( - '- The reopened physical gate is now closed on exact clean measurement head ' - '`2701aa9feb3796c33c94e6480fcb78c80c6a809c`: Tesla P100 CuPy and Torch each passed all 17 estimator cases and all five Hausman diagnostics with requested/executed backend identity and no CPU fallback. ' - 'The dedicated 48-observation nonzero-effect fixture is `applicable=true` on both backends with df=1; its Hausman statistic differs from NumPy by at most `1.10e-13` and p-value by at most `2.19e-14`. ' - 'The promoted 44-row canonical validation source preserves statistic/pvalue/df for that branch, while the older 42-row a57efcea source remains historical audit evidence. No timing or speedup claim is made.' - ) - en_path.write_text('\n'.join(en_lines) + '\n', encoding='utf-8') - - cn_path = root / 'docs/cn/changelog.md' - cn_lines = cn_path.read_text(encoding='utf-8').splitlines() - cn_idx = [i for i, line in enumerate(cn_lines) if line.startswith('- Ready-for-review 审计因此重新打开 physical gate')] - assert len(cn_idx) == 1 - cn_lines[cn_idx[0]] = ( - '- 重新打开的 physical gate 已在精确 clean measurement head ' - '`2701aa9feb3796c33c94e6480fcb78c80c6a809c` 上闭合：Tesla P100 的 CuPy 与 Torch 各自通过全部 17 个 estimator case 和 5 个 Hausman diagnostic，requested/executed backend 一致且没有 CPU fallback。' - '新增的 48-observation nonzero-effect fixture 在两个 backend 上均为 `applicable=true`、df=1；Hausman statistic 相对 NumPy 的最大差异不超过 `1.10e-13`，p-value 不超过 `2.19e-14`。' - '新的 44-row canonical validation source 保留该分支的 statistic/pvalue/df；旧的 42-row a57efcea source 继续作为历史审计证据保留。本次证据不包含 timing 或 speedup 声明。' - ) - cn_path.write_text('\n'.join(cn_lines) + '\n', encoding='utf-8') - - review_path = root / 'dev/reviews/pr122_physical_gpu_validation.md' - review_path.write_text(f'''# PR #122 Panel Stage B physical GPU validation\n\n## Physical acceptance status\n\n**PHYSICAL_GPU_ACCEPTED** for the Stage-B runner measured at exact clean implementation head `{measurement_sha}`.\n\nThis status covers the active physical correctness/backend-provenance gate only. Exact-final-head hosted CI and a fresh `.claude/skills/code-review.md` review remain lifecycle gates after evidence promotion; the physical runner itself must not change without another P100 rerun.\n\n## Accepted full P100 artifact\n\n- path: `{raw_rel}`\n- measurement SHA: `{measurement_sha}`\n- artifact repository commit: `{artifact_commit}`\n- Git blob: `{raw_blob}`\n- schema version: 2\n- working tree clean: true\n- top-level status: success\n- GPU: Tesla P100-SXM2-16GB\n- Python: 3.9.16\n- NumPy: 1.24.2\n- SciPy: 1.10.1\n- Torch: 2.0.0\n- timing collected: false\n\nFor both CuPy and Torch, all 17 estimator cases passed with the requested backend actually executed and no CPU fallback.\n\n## Hausman branch coverage\n\nEach backend passed five Hausman diagnostics:\n\n1. `hausman_balanced` — structured `applicable=false` / non-PSD covariance difference;\n2. `hausman_explicit_re_constant_balanced` — structured `applicable=false`;\n3. `hausman_unbalanced` — structured `applicable=false`;\n4. `hausman_explicit_re_constant_unbalanced` — structured `applicable=false`;\n5. `hausman_applicable_nonzero_effect` — **`applicable=true`**, df=1.\n\nFor the dedicated applicable fixture, CuPy recorded statistic `1.1965942530851057` and p-value `0.27400344142676447`; Torch recorded statistic `1.1965942530849238` and p-value `0.2740034414268009`; the NumPy reference is statistic `1.196594253085033`, p-value `0.274003441426779`, df=1. Maximum statistic differences are `7.26e-14` (CuPy) and `1.09e-13` (Torch), and all FE/RE coefficient/covariance differences are below `1e-12`.\n\nThe fixture uses seed 20260810, 12 entities, 4 observations per entity, one slope, entity-effect scale 0.005, and noise scale 0.1. Its NumPy FE-minus-RE diagnostic covariance margin is `4.6413153162319366e-05`, safely above the hosted stability guard.\n\n## Supplementary disconnected-FE evidence\n\nThe focused disconnected two-way FE artifact remains valid supplementary evidence for an unchanged numerical path:\n\n- path: `{focused_rel}`\n- measurement SHA: `{historical_measurement_sha}`\n- artifact repository commit: `{historical_artifact_commit}`\n- Git blob: `{focused_blob}`\n- legacy residual df: 0\n- component-aware/public residual df: 1\n- effect rank: 7\n- incidence components: 3\n- CuPy/Torch confidence intervals agree with NumPy at floating-point noise.\n\nIt is deliberately identified as historical supplementary evidence rather than relabeled as a `{measurement_sha}` measurement.\n\n## Promoted canonical evidence\n\n- canonical path: `{new_source_rel}`\n- canonical SHA-256: `{promoted_sha256}`\n- source id: `{source_id}`\n- validation rows: 44 = 17 estimator cases x 2 backends + 5 Hausman diagnostics x 2 backends\n- timing/speedup: absent by contract\n\nThe parser requires the dedicated applicable row to preserve finite nonnegative statistic, p-value in [0,1], and positive df; missing or invalid numeric evidence fails closed. The older 42-row canonical source remains in the repository as explicitly superseded historical audit evidence and is no longer the registered source.\n\n## Physical conclusion\n\nThe P2 finding “Require an applicable Hausman case in the GPU gate” is physically closed. Both physical backends now exercise the applicable statistic/p-value/df path and the structured-inapplicable path without fallback.\n\n**Physical gate: ACCEPTED.**\n''', encoding='utf-8') - - print('promoted source:', new_source_rel) - print('source sha256:', promoted_sha256) - print('source id:', source_id) - print('raw blob:', raw_blob) - PY - - name: Generate canonical frontend assets - run: | - python dev/benchmarks/generate_benchmark_data.py \ - --out frontend/public/data/benchmark_data.json \ - --report frontend/public/data/parse_report.json \ - --inventory-out frontend/public/data/source_inventory.json \ - --deterministic --strict-sources - - uses: actions/setup-node@v4 - with: - node-version: '20' - - name: Build docs mirror - working-directory: frontend - run: | - npm ci - npm run build - - name: Run focused canonical and catalog gates - run: | - python -m pytest \ - dev/tests/test_panel_stage_b_frontend_source.py \ - dev/tests/test_panel_stage_b_applicable_hausman_parser.py \ - dev/tests/test_benchmark_frontend_data.py \ - dev/tests/test_benchmark_catalog.py \ - dev/tests/test_benchmark_inventory_v2.py \ - dev/tests/test_frontend_contracts.py \ - dev/tests/test_frontend_domain_coverage.py -q - python dev/benchmarks/generate_benchmark_data.py --check --strict-sources - git diff --check - - name: Commit promoted evidence and remove one-shot workflow - run: | - rm .github/workflows/pr122-finalize-evidence.yml - git config user.name 'github-actions[bot]' - git config user.email '41898282+github-actions[bot]@users.noreply.github.com' - echo 'Final changed paths:' - git status --short - git add -A - git commit -m 'benchmark: finalize PR122 Stage B physical evidence' - git push origin HEAD:agent/panel-p1-stage-b-diagnostics From d47575dc897822ab2c45813813db0f3fe4807bae Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 22:41:30 +0800 Subject: [PATCH 164/165] ci: remove PR122 evidence retry carrier --- .../pr122-finalize-evidence-retry.yml | 51 ------------------- 1 file changed, 51 deletions(-) delete mode 100644 .github/workflows/pr122-finalize-evidence-retry.yml diff --git a/.github/workflows/pr122-finalize-evidence-retry.yml b/.github/workflows/pr122-finalize-evidence-retry.yml deleted file mode 100644 index dd895e043..000000000 --- a/.github/workflows/pr122-finalize-evidence-retry.yml +++ /dev/null @@ -1,51 +0,0 @@ -name: PR122 retry evidence contract - -on: - push: - branches: [agent/panel-p1-stage-b-diagnostics] - paths: - - '.github/workflows/pr122-finalize-evidence-retry.yml' - -permissions: - contents: write - -jobs: - update-contract: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v4 - with: - fetch-depth: 0 - - name: Update Stage-B domain coverage contract - env: - REPLACEMENT_B64: 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 - run: | - python - <<'PY' - import base64 - import os - import re - from pathlib import Path - path = Path('dev/tests/test_frontend_domain_coverage.py') - text = path.read_text(encoding='utf-8') - replacement = base64.b64decode(os.environ['REPLACEMENT_B64']).decode('utf-8') - text, count = re.subn( - r'def test_panel_stage_b_physical_validation_is_published_without_timing\(canonical_output\):\n.*?(?=\ndef test_unsupervised_exposes_complete_source_matrix)', - replacement, - text, - flags=re.S, - ) - assert count == 1, count - old_count = 'assert len(output["runs"]) == 1860\n assert report["runs_generated"] == 1860' - new_count = 'assert len(output["runs"]) == 1862\n assert report["runs_generated"] == 1862' - assert old_count in text - text = text.replace(old_count, new_count) - path.write_text(text, encoding='utf-8') - PY - - name: Commit only the domain contract - run: | - git diff --check - git config user.name 'github-actions[bot]' - git config user.email '41898282+github-actions[bot]@users.noreply.github.com' - git add dev/tests/test_frontend_domain_coverage.py - git commit -m 'test: align PR122 final frontend coverage' - git push origin HEAD:agent/panel-p1-stage-b-diagnostics From cdff57179d97cd53863681cfa46301da919999ec Mon Sep 17 00:00:00 2001 From: Ziqian Lin <51812297+TheHiddenObserver@users.noreply.github.com> Date: Sun, 9 Aug 2026 22:41:42 +0800 Subject: [PATCH 165/165] ci: remove PR122 final evidence carrier --- .../workflows/pr122-finalize-evidence-v3.yml | 80 ------------------- 1 file changed, 80 deletions(-) delete mode 100644 .github/workflows/pr122-finalize-evidence-v3.yml diff --git a/.github/workflows/pr122-finalize-evidence-v3.yml b/.github/workflows/pr122-finalize-evidence-v3.yml deleted file mode 100644 index b0c0f607e..000000000 --- a/.github/workflows/pr122-finalize-evidence-v3.yml +++ /dev/null @@ -1,80 +0,0 @@ -name: PR122 final evidence promotion v3 - -on: - push: - branches: [agent/panel-p1-stage-b-diagnostics] - paths: - - '.github/workflows/pr122-finalize-evidence-v3.yml' - -permissions: - contents: write - -jobs: - promote: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v4 - with: - fetch-depth: 0 - - uses: actions/setup-python@v5 - with: - python-version: '3.11' - - name: Install validation dependencies - run: python -m pip install -U pip pytest 'jsonschema[format]' - - name: Execute reviewed promotion step - run: | - python - <<'PY' - from pathlib import Path - source = Path('.github/workflows/pr122-finalize-evidence.yml').read_text(encoding='utf-8') - start_marker = " - name: Promote exact-head P100 evidence and contracts\n run: |\n" - end_marker = "\n - name: Generate canonical frontend assets" - start = source.index(start_marker) + len(start_marker) - end = source.index(end_marker, start) - block = source[start:end] - lines = [] - for line in block.splitlines(): - if line.startswith(' '): - lines.append(line[10:]) - elif line: - raise SystemExit(f'unexpected promotion indentation: {line!r}') - else: - lines.append('') - Path('/tmp/pr122-promote.sh').write_text('\n'.join(lines) + '\n', encoding='utf-8') - PY - bash /tmp/pr122-promote.sh - - name: Generate canonical frontend assets - run: | - python dev/benchmarks/generate_benchmark_data.py \ - --out frontend/public/data/benchmark_data.json \ - --report frontend/public/data/parse_report.json \ - --inventory-out frontend/public/data/source_inventory.json \ - --deterministic --strict-sources - - uses: actions/setup-node@v4 - with: - node-version: '20' - - name: Build docs mirror - working-directory: frontend - run: | - npm ci - npm run build - - name: Run focused promotion gates - run: | - python -m pytest \ - dev/tests/test_panel_stage_b_frontend_source.py \ - dev/tests/test_panel_stage_b_applicable_hausman_parser.py \ - dev/tests/test_benchmark_frontend_data.py \ - dev/tests/test_benchmark_catalog.py \ - dev/tests/test_benchmark_inventory_v2.py \ - dev/tests/test_frontend_contracts.py \ - dev/tests/test_frontend_domain_coverage.py -q - python dev/benchmarks/generate_benchmark_data.py --check --strict-sources - git diff --check - - name: Commit promoted evidence - run: | - git config user.name 'github-actions[bot]' - git config user.email '41898282+github-actions[bot]@users.noreply.github.com' - echo 'Promoted changed paths:' - git status --short - git add -A - git commit -m 'benchmark: finalize PR122 Stage B physical evidence' - git push origin HEAD:agent/panel-p1-stage-b-diagnostics