diff --git a/.github/workflows/benchmark-frontend.yml b/.github/workflows/benchmark-frontend.yml index d6d51e2e6..f7966aaf3 100644 --- a/.github/workflows/benchmark-frontend.yml +++ b/.github/workflows/benchmark-frontend.yml @@ -16,10 +16,12 @@ on: - '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/test_panel_stage_c_frontend_source.py' - 'dev/tests/fixtures/benchmark_frontend/**' - 'frontend/**' - 'docs/assets/benchmarks/**' - 'results/benchmark_frontend_sources/**' + - 'results/pr126_p100/**' - 'pyproject.toml' pull_request: paths: @@ -35,10 +37,12 @@ on: - '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/test_panel_stage_c_frontend_source.py' - 'dev/tests/fixtures/benchmark_frontend/**' - 'frontend/**' - 'docs/assets/benchmarks/**' - 'results/benchmark_frontend_sources/**' + - 'results/pr126_p100/**' - 'pyproject.toml' concurrency: @@ -70,7 +74,8 @@ jobs: 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 -v + dev/tests/test_panel_stage_b_applicable_hausman_parser.py \ + dev/tests/test_panel_stage_c_frontend_source.py -v - name: Validate generator output run: python dev/benchmarks/generate_benchmark_data.py --check --strict-sources diff --git a/.github/workflows/panel-stage-c-external.yml b/.github/workflows/panel-stage-c-external.yml new file mode 100644 index 000000000..9f914c409 --- /dev/null +++ b/.github/workflows/panel-stage-c-external.yml @@ -0,0 +1,86 @@ +name: Panel Stage C external covariance + +on: + pull_request: + branches: [master] + paths: + - 'statgpu/panel/**' + - 'dev/tests/test_panel_stage_c_external.py' + - 'dev/tests/test_panel_stage_c_external_defaults.py' + - 'dev/tests/test_panel_stage_c_linearmodels_estimators.py' + - 'dev/tests/test_panel_stage_c_r_external.py' + - '.github/workflows/panel-stage-c-external.yml' + push: + branches: [master] + paths: + - 'statgpu/panel/**' + - 'dev/tests/test_panel_stage_c_external.py' + - 'dev/tests/test_panel_stage_c_external_defaults.py' + - 'dev/tests/test_panel_stage_c_linearmodels_estimators.py' + - 'dev/tests/test_panel_stage_c_r_external.py' + - '.github/workflows/panel-stage-c-external.yml' + +permissions: + contents: read + +jobs: + external-definitions: + runs-on: ubuntu-latest + timeout-minutes: 15 + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: '3.11' + - name: Install pinned references + run: | + python -m pip install --upgrade pip + python -m pip install -e . 'linearmodels==7.0' 'statsmodels==0.14.6' pytest + - name: Confirm reference versions + run: | + python - <<'PY' + import linearmodels, statsmodels + assert linearmodels.__version__ == '7.0' + assert statsmodels.__version__ == '0.14.6' + print('linearmodels', linearmodels.__version__) + print('statsmodels', statsmodels.__version__) + PY + - name: Run Stage C external covariance alignment + run: | + python -m pytest \ + dev/tests/test_panel_stage_c_external.py \ + dev/tests/test_panel_stage_c_external_defaults.py \ + dev/tests/test_panel_stage_c_linearmodels_estimators.py \ + -q --tb=short + + r-external-alignment: + runs-on: ubuntu-latest + timeout-minutes: 30 + env: + STATGPU_RUN_R_PANEL_EXTERNAL: '1' + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: '3.11' + - uses: r-lib/actions/setup-r@v2 + with: + r-version: '4.4.2' + - name: Install statgpu test environment + run: | + python -m pip install --upgrade pip + python -m pip install -e . pytest + - name: Install R external references + run: | + Rscript - <<'RS' + options(repos = c(CRAN = 'https://cloud.r-project.org')) + install.packages(c('sandwich', 'plm'), Ncpus = 2L) + stopifnot(requireNamespace('sandwich', quietly = TRUE)) + stopifnot(requireNamespace('plm', quietly = TRUE)) + cat('R', R.version.string, '\n') + cat('plm', as.character(packageVersion('plm')), '\n') + cat('sandwich', as.character(packageVersion('sandwich')), '\n') + RS + - name: Run R plm and sandwich alignment + run: | + python -m pytest dev/tests/test_panel_stage_c_r_external.py -q --tb=short diff --git a/.github/workflows/panel-stage-c-torch-cpu.yml b/.github/workflows/panel-stage-c-torch-cpu.yml new file mode 100644 index 000000000..4e74e9765 --- /dev/null +++ b/.github/workflows/panel-stage-c-torch-cpu.yml @@ -0,0 +1,44 @@ +name: Panel Stage C Torch CPU + +on: + pull_request: + branches: [master] + paths: + - 'statgpu/panel/**' + - 'dev/tests/test_panel_stage_c_torch_cpu.py' + - '.github/workflows/panel-stage-c-torch-cpu.yml' + push: + branches: [master] + paths: + - 'statgpu/panel/**' + - 'dev/tests/test_panel_stage_c_torch_cpu.py' + - '.github/workflows/panel-stage-c-torch-cpu.yml' + +permissions: + contents: read + +jobs: + torch-2-0-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 maintained Torch CPU 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 maintained Torch version + 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 Stage C Torch CPU covariance parity + run: python -m pytest dev/tests/test_panel_stage_c_torch_cpu.py -q --tb=short diff --git a/CHANGELOG.md b/CHANGELOG.md index f65151c32..1a9317804 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,14 @@ All notable changes to statgpu are documented here, organized by release and date. +## 2026-08-09 + +### PR #126 — Complete Panel Tier-1 Stage C covariance +- Added HC0/HC2/HC3, robust RandomEffects inference, cluster group debiasing, and Driscoll-Kraay covariance with NumPy/CuPy/Torch-native accumulation. +- Preserved historical HC1 (`robust`), Pooled row-HAC, default clustered covariance, coefficient estimates, and Stage-B diagnostics. +- Hardened covariance numerics around the design pseudoinverse, stable HC2/HC3 leverage, metadata validation, backend-native CuPy scatter-add, unified inference storage, RandomEffects formula intercept/name semantics, and small-argument QS weights; pinned Python and R external alignment remains green. +- Fresh Tesla P100 acceptance on exact clean implementation head `aad53587c9611da0e71a676e86ef32d9f6403f5c` passes all 26 estimator covariance cases plus 6 direct public primitives on each of CuPy and Torch (32/32 per backend), including ill-conditioned HC0/HC2/HC3/DK and persisted executed-backend provenance. Synchronized performance evidence covers the maintained base scales and bounded `N=10,000`, `k=2`, `T=200` QS all-lag scenario without making a speedup claim. Earlier `c151550a...` and `9c0b3050...` artifacts remain immutable historical evidence. + ## 2026-08-08 ### PR #122 — Panel Tier-1 diagnostics Stage B diff --git a/dev/benchmarks/benchmark_coverage_matrix.json b/dev/benchmarks/benchmark_coverage_matrix.json index 296b0514b..2a0cc9745 100644 --- a/dev/benchmarks/benchmark_coverage_matrix.json +++ b/dev/benchmarks/benchmark_coverage_matrix.json @@ -86,7 +86,9 @@ "status": "partial_canonical", "source_ids": [ "new-modules-20260624-bcbdb676223b", - "panel-stage-b-pr122-20260809-2056f836bfe2" + "panel-stage-b-pr122-20260809-2056f836bfe2", + "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "panel-stage-c-performance-pr126-20260810-99208f9276b9" ], "representative_dimensions": [ "estimator", @@ -94,10 +96,13 @@ "aligned_scale", "physical_validation", "diagnostics", - "inference_regression" + "inference_regression", + "covariance", + "n_times", + "timing_protocol" ], "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." + "disposition": "June timing rows cover aligned PanelOLS and RandomEffects; PR #122 provides canonical Stage-B diagnostic/physical validation. PR #126 repaired exact-clean P100 evidence at aad53587 adds canonical Stage-C CuPy/Torch correctness for 26 estimator covariance integrations plus six direct public primitives per backend, including ill-conditioned HC0/HC2/HC3/DK, and synchronized timing for three base scales plus a bounded N=10,000, k=2, T=200 QS all-lag scenario. The c151550a and 9c0b3050 artifacts are retained only as historical evidence. No Stage-C speedup claim is made." }, { "capability_id": "gam-nonparametric", diff --git a/dev/benchmarks/benchmark_panel_stage_c_covariance.py b/dev/benchmarks/benchmark_panel_stage_c_covariance.py new file mode 100644 index 000000000..6fd9411a4 --- /dev/null +++ b/dev/benchmarks/benchmark_panel_stage_c_covariance.py @@ -0,0 +1,308 @@ +#!/usr/bin/env python3 +"""Physical performance probe for Panel Stage-C covariance paths. + +This benchmark is intentionally separate from the correctness validator. It +measures synchronized end-to-end fit time for representative covariance paths +and records raw samples without making a speedup promise. +""" + +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 + +from statgpu.panel import PanelOLS, PooledOLS, RandomEffects + + +PERFORMANCE_SCHEMA_VERSION = 2 +DEFAULT_HIGH_T_SCALE = "10000x2x200" +HIGH_T_CASES = ("pooled_dk_qs", "panel_entity_dk_qs") + + +def _git_sha(): + return subprocess.check_output(["git", "rev-parse", "HEAD"], text=True).strip() + + +def _git_status(): + return subprocess.check_output(["git", "status", "--porcelain"], text=True) + + +def _version(name): + try: + return importlib.metadata.version(name) + except importlib.metadata.PackageNotFoundError: + return None + + +def _parse_scales(text): + values = [] + for token in text.split(","): + n_text, k_text = token.strip().lower().split("x", 1) + n, k = int(n_text), int(k_text) + if n <= 0 or k <= 0: + raise ValueError("scales must be positive NxK pairs") + values.append((n, k)) + return values + + +def _parse_high_t_scale(text): + parts = text.strip().lower().split("x") + if len(parts) != 3: + raise ValueError("high-T scale must be an NxKxT triple") + n, k, n_times = (int(v) for v in parts) + if n <= 0 or k <= 0 or n_times < 2 or n < n_times: + raise ValueError("high-T scale requires positive N/K, T>=2, and N>=T") + return n, k, n_times + + +def _timing_row(*, backend, case, scenario, n, k, n_times, repeats, samples): + return { + "backend": backend, + "case": case, + "scenario": scenario, + "n_samples": int(n), + "n_features": int(k), + "n_times": int(n_times), + "repeats": int(repeats), + "median_seconds": float(np.median(samples)), + "samples_seconds": [float(v) for v in samples], + } + + +def _sync(backend): + if backend == "cupy": + import cupy as cp + cp.cuda.Stream.null.synchronize() + elif backend == "torch": + import torch + torch.cuda.synchronize() + + +def _dataset(n, k, seed, *, n_times=20): + if int(n_times) < 2 or int(n) < int(n_times): + raise ValueError("dataset requires n_times>=2 and n>=n_times") + rng = np.random.default_rng(seed) + n_times = int(n_times) + n_entities = max(2, int(np.ceil(n / n_times))) + entity = np.repeat(np.arange(n_entities), n_times)[:n] + time_ids = np.tile(np.arange(n_times), n_entities)[:n] + X = rng.normal(size=(n, k)).astype(np.float64) + beta = np.linspace(0.15, 0.75, k, dtype=np.float64) + alpha_values = rng.normal(scale=0.35, size=n_entities) + y = X @ beta + alpha_values[entity] + rng.normal(scale=0.25, size=n) + clusters = np.column_stack([entity, time_ids]) + return X, y.astype(np.float64), entity, time_ids, clusters + + +def _to_backend(X, y, entity, time_ids, backend): + if backend == "cupy": + import cupy as cp + return ( + cp.asarray(X), cp.asarray(y), + cp.asarray(entity, dtype=cp.int64), + cp.asarray(time_ids, 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_ids, dtype=torch.int64, device="cuda"), + ) + raise ValueError(backend) + + +def _device(backend): + return {"cupy": "cuda", "torch": "torch"}[backend] + + +def _gpu_name(backend): + if backend == "cupy": + import cupy as cp + + props = cp.cuda.runtime.getDeviceProperties(0) + name = props["name"] + return name.decode() if isinstance(name, bytes) else str(name) + if backend == "torch": + import torch + + if not torch.cuda.is_available(): + raise RuntimeError("Torch backend requested but CUDA is unavailable") + return torch.cuda.get_device_name(0) + raise ValueError(backend) + + +def _fit_case(case, X, y, entity, time_ids, clusters, backend): + device = _device(backend) + if case == "pooled_nonrobust": + return PooledOLS(cov_type="nonrobust", device=device).fit(X, y) + if case == "pooled_hc3": + return PooledOLS(cov_type="hc3", device=device).fit(X, y) + if case == "pooled_cluster_two_way": + return PooledOLS(cov_type="clustered", group_debias=True, device=device).fit( + X, y, cluster=clusters + ) + if case == "pooled_dk_qs": + return PooledOLS(cov_type="dk", bandwidth=2, kernel="qs", device=device).fit( + X, y, time_index=time_ids + ) + if case == "panel_entity_nonrobust": + return PanelOLS(entity_effects=True, cov_type="nonrobust", device=device).fit( + X, y, entity_ids=entity + ) + if case == "panel_entity_hc3": + return PanelOLS(entity_effects=True, cov_type="hc3", device=device).fit( + X, y, entity_ids=entity + ) + if case == "panel_entity_dk": + return PanelOLS( + entity_effects=True, cov_type="dk", bandwidth=2, device=device + ).fit(X, y, entity_ids=entity, time_ids=time_ids) + if case == "panel_entity_dk_qs": + return PanelOLS( + entity_effects=True, cov_type="dk", bandwidth=2, kernel="qs", device=device + ).fit(X, y, entity_ids=entity, time_ids=time_ids) + if case == "random_effects_nonrobust": + return RandomEffects(device=device).fit(X, y, entity_ids=entity) + if case == "random_effects_hc3": + return RandomEffects(cov_type="hc3", device=device).fit(X, y, entity_ids=entity) + raise ValueError(case) + + +def _timed(case, X, y, entity, time_ids, clusters, backend): + _sync(backend) + start = time.perf_counter() + model = _fit_case(case, X, y, entity, time_ids, clusters, backend) + _sync(backend) + elapsed = time.perf_counter() - start + executed = getattr(model, "_backend_name", None) + if executed is None: + raise AssertionError(f"{case}: fit did not persist executed backend provenance") + if executed != backend: + raise AssertionError(f"{case}: requested {backend}, executed {executed}") + return elapsed + + +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") + parser.add_argument( + "--high-t-scale", + default=DEFAULT_HIGH_T_SCALE, + help="additional NxKxT scenario used only for QS all-lag cases", + ) + parser.add_argument("--repeats", type=int, default=3) + args = parser.parse_args() + + if _git_sha() != args.expected_sha: + raise RuntimeError(f"wrong source head: {_git_sha()} != {args.expected_sha}") + dirty = _git_status() + if dirty.strip(): + raise RuntimeError("performance benchmark requires a clean tree:\n" + dirty) + if args.repeats < 1: + raise ValueError("repeats must be positive") + backends = [v.strip() for v in args.backends.split(",") if v.strip()] + if not backends or any(v not in {"cupy", "torch"} for v in backends): + raise ValueError("backends must contain cupy and/or torch") + + cases = [ + "pooled_nonrobust", "pooled_hc3", "pooled_cluster_two_way", "pooled_dk_qs", + "panel_entity_nonrobust", "panel_entity_hc3", "panel_entity_dk", + "random_effects_nonrobust", "random_effects_hc3", + ] + rows = [] + for scale_idx, (n, k) in enumerate(_parse_scales(args.scales)): + X_np, y_np, entity_np, time_np, clusters = _dataset( + n, k, 20260812 + scale_idx, n_times=20 + ) + for backend in backends: + X, y, entity, time_ids = _to_backend( + X_np, y_np, entity_np, time_np, backend + ) + for case in cases: + _timed(case, X, y, entity, time_ids, clusters, backend) + samples = [ + _timed(case, X, y, entity, time_ids, clusters, backend) + for _ in range(args.repeats) + ] + rows.append( + _timing_row( + backend=backend, + case=case, + scenario="base", + n=n, + k=k, + n_times=len(np.unique(time_np)), + repeats=args.repeats, + samples=samples, + ) + ) + + high_n, high_k, high_t = _parse_high_t_scale(args.high_t_scale) + X_np, y_np, entity_np, time_np, clusters = _dataset( + high_n, high_k, 20260899, n_times=high_t + ) + for backend in backends: + X, y, entity, time_ids = _to_backend( + X_np, y_np, entity_np, time_np, backend + ) + for case in HIGH_T_CASES: + _timed(case, X, y, entity, time_ids, clusters, backend) + samples = [ + _timed(case, X, y, entity, time_ids, clusters, backend) + for _ in range(args.repeats) + ] + rows.append( + _timing_row( + backend=backend, + case=case, + scenario="high_t_qs", + n=high_n, + k=high_k, + n_times=len(np.unique(time_np)), + repeats=args.repeats, + samples=samples, + ) + ) + + payload = { + "schema_version": PERFORMANCE_SCHEMA_VERSION, + "git_sha": args.expected_sha, + "working_tree_clean": True, + "benchmark": "panel_stage_c_covariance_fit_overhead", + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": ( + "X/y/entity/time preloaded on selected GPU backend; " + "cluster labels remain CPU metadata" + ), + "high_t_scale": args.high_t_scale, + "environment": { + "python": platform.python_version(), + "platform": platform.platform(), + "gpu_by_backend": {backend: _gpu_name(backend) for backend in backends}, + "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 — Panel Stage C performance evidence recorded: {args.out}") + + +if __name__ == "__main__": + main() diff --git a/dev/benchmarks/frontend_data/parsers/__init__.py b/dev/benchmarks/frontend_data/parsers/__init__.py index 0ac0a7d61..a43eab1f5 100644 --- a/dev/benchmarks/frontend_data/parsers/__init__.py +++ b/dev/benchmarks/frontend_data/parsers/__init__.py @@ -19,6 +19,10 @@ 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 +from .panel_stage_c import ( + parse_panel_stage_c_physical_validation, + parse_panel_stage_c_performance, +) __all__ = [ "parse_penalized_glm_bench_perf", @@ -38,4 +42,6 @@ "parse_new_modules_with_anova_benchmark", "parse_p2_benchmark", "parse_panel_stage_b_physical_validation", + "parse_panel_stage_c_physical_validation", + "parse_panel_stage_c_performance", ] diff --git a/dev/benchmarks/frontend_data/parsers/panel_stage_c.py b/dev/benchmarks/frontend_data/parsers/panel_stage_c.py new file mode 100644 index 000000000..163ebded0 --- /dev/null +++ b/dev/benchmarks/frontend_data/parsers/panel_stage_c.py @@ -0,0 +1,417 @@ +from __future__ import annotations +"""Canonical parsers for PR #126 Panel Stage-C P100 evidence.""" + +import hashlib +import json +import math +import statistics +from pathlib import Path +from typing import Any + +from ..canonical import make_scale_key, make_scale_label + +_SOURCE_DATE = "2026-08-10" +_MEASUREMENT_SHA = "aad53587c9611da0e71a676e86ef32d9f6403f5c" +_VALIDATION_PARSER = "parse_panel_stage_c_physical_validation_v1" +_PERFORMANCE_PARSER = "parse_panel_stage_c_performance_v1" +_PARSER_VERSION = "1.0" + +_EXPECTED_CASES = { + "pooled_hc0", "pooled_hc2", "pooled_hc3", + "pooled_cluster_one_way", "pooled_cluster_two_way_group_debias", + "pooled_dk_bartlett", "pooled_dk_qs", "pooled_legacy_hac", + "panel_entity_hc0", "panel_entity_hc2", "panel_entity_hc3", + "panel_two_way_hc3", "panel_two_way_cluster_group_debias", "panel_two_way_dk", + "random_effects_explicit_constant_robust", "random_effects_explicit_constant_hc0", + "random_effects_explicit_constant_hc2", "random_effects_explicit_constant_hc3", + "random_effects_cluster_two_way", "random_effects_dk", + "between_hc0", "between_hc2", "between_hc3", + "first_difference_hc0", "first_difference_hc2", "first_difference_hc3", +} +_EXPECTED_PRIMITIVES = { + "cluster_group_debias", "driscoll_kraay_qs", + "ill_conditioned_hc0", "ill_conditioned_hc2", + "ill_conditioned_hc3", "ill_conditioned_dk", +} +_BASE_CASES = { + "pooled_nonrobust", "pooled_hc3", "pooled_cluster_two_way", "pooled_dk_qs", + "panel_entity_nonrobust", "panel_entity_hc3", "panel_entity_dk", + "random_effects_nonrobust", "random_effects_hc3", +} +_BASE_SCALES = {(10000, 2, 20), (100000, 2, 20), (100000, 10, 20)} +_HIGH_T_CASES = {"pooled_dk_qs", "panel_entity_dk_qs"} + + +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 _model_id(case: str) -> str: + if case.startswith("pooled_"): + return "PooledOLS" + if case.startswith("panel_"): + return "PanelOLS" + if case.startswith("random_effects_"): + return "RandomEffects" + if case.startswith("between_"): + return "BetweenOLS" + if case.startswith("first_difference_"): + return "FirstDifferenceOLS" + raise ValueError(f"unknown Stage-C case identity: {case!r}") + + +def _scale( + n_samples: int, + n_features: int, + *, + suffix: str | None = None, + key_suffix: str | None = None, +) -> dict[str, Any]: + label = make_scale_label(int(n_samples), int(n_features)) + if suffix: + label = f"{label} · {suffix}" + scale_key = make_scale_key(int(n_samples), int(n_features)) + if key_suffix: + scale_key = f"{scale_key}_{key_suffix}" + return { + "scale_key": scale_key, + "n_samples": int(n_samples), + "n_features": int(n_features), + "label": label, + } + + +def _models(model_ids: set[str]) -> list[dict]: + return [ + { + "model_id": model_id, + "primary_category_id": "panel", + "category_ids": ["panel"], + "supports_penalty": False, + "supports_inference": True, + } + for model_id in sorted(model_ids) + ] + + +def _source(filepath: Path, parser: str) -> dict[str, str]: + return { + "file": filepath.name, + "date": _SOURCE_DATE, + "parser": parser, + "parser_version": _PARSER_VERSION, + } + + +def _validation(ok: bool, filepath: Path, checks: list[dict[str, Any]]) -> dict[str, Any]: + return { + "status": "pass" if ok else "fail", + "checks": checks, + "quality": "reported", + "source_file": filepath.name, + } + + +def _bool_check(metric: str, ok: bool, **extra: Any) -> dict[str, Any]: + return {"metric": metric, "status": "pass" if ok else "fail", **extra} + + +def _finite_diff_map(value: Any) -> bool: + """Validate stored difference diagnostics; runner success owns rtol+atol parity.""" + if not isinstance(value, dict) or not value: + return False + for item in value.values(): + if isinstance(item, bool) or not isinstance(item, (int, float)): + return False + item = float(item) + if not math.isfinite(item) or item < 0.0: + return False + return True + + +def parse_panel_stage_c_physical_validation( + filepath: Path, env_id: str +) -> tuple[list[dict], list[dict], list[str]]: + data = json.loads(filepath.read_text(encoding="utf-8")) + warnings: list[str] = [] + if int(data.get("schema_version", -1)) != 1: + raise ValueError("PR126 Stage-C validation source requires schema_version=1") + if data.get("git_sha") != _MEASUREMENT_SHA: + raise ValueError("PR126 Stage-C validation source measurement SHA drifted") + if int(data.get("case_count_per_backend", -1)) != len(_EXPECTED_CASES): + raise ValueError("PR126 Stage-C validation estimator case count drifted") + if int(data.get("public_primitive_count_per_backend", -1)) != len(_EXPECTED_PRIMITIVES): + raise ValueError("PR126 Stage-C public primitive count drifted") + + dataset = data.get("dataset", {}) + scale = _scale(dataset.get("nobs", 0), dataset.get("n_features", 0)) + source_ok = data.get("status") == "success" and data.get("working_tree_clean") is True + runs: list[dict] = [] + model_ids: set[str] = set() + + backends = data.get("backends", {}) + if set(backends) != {"cupy", "torch"}: + raise ValueError("PR126 Stage-C validation requires exactly CuPy and Torch backends") + + for backend in ("cupy", "torch"): + result = backends[backend] + cases = result.get("cases", {}) + primitives = result.get("public_primitives", {}) + if set(cases) != _EXPECTED_CASES: + raise ValueError(f"{backend}: PR126 estimator case identity drifted") + if set(primitives) != _EXPECTED_PRIMITIVES: + raise ValueError(f"{backend}: PR126 public primitive identity drifted") + backend_ok = ( + result.get("status") == "success" + and result.get("requested_backend") == backend + ) + + for case_name in sorted(_EXPECTED_CASES): + case = cases[case_name] + diff_ok = _finite_diff_map(case.get("max_abs_differences")) + executed_ok = case.get("executed_backend") == backend + case_ok = case.get("status") == "success" + ok = source_ok and backend_ok and case_ok and executed_ok and diff_ok + checks = [ + _bool_check("source_status_success", source_ok), + _bool_check("backend_status_success", backend_ok), + _bool_check("case_status_success", case_ok), + _bool_check("executed_backend_matches_requested", executed_ok), + _bool_check("recorded_numpy_difference_finite", diff_ok), + ] + model_id = _model_id(case_name) + model_ids.add(model_id) + runs.append( + { + "run_id": "", + "benchmark_session_id": f"{env_id}-panel-stage-c-pr126-validation", + "env_id": env_id, + "category_ids": ["panel"], + "model_id": model_id, + "case_id": _stable_id("case", "stage-c", case_name, scale["scale_key"]), + "method_config_id": _stable_id("method", "stage-c-physical", case_name), + "variant": case_name.replace("_", "-"), + "penalty": None, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": backend, + "scale": dict(scale), + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": data.get("git_sha"), + "working_tree_clean": bool(data.get("working_tree_clean")), + "executed_backend": case.get("executed_backend"), + "covariance_metadata": case.get("covariance_metadata", {}), + }, + "source": _source(filepath, _VALIDATION_PARSER), + "metrics": { + "validation": _validation(ok, filepath, checks), + "inference": { + "ok": ok, + "quality": "reported", + "source_file": filepath.name, + }, + }, + } + ) + + for primitive_name in sorted(_EXPECTED_PRIMITIVES): + item = primitives[primitive_name] + try: + diff = float(item.get("max_abs_difference")) + diff_ok = math.isfinite(diff) and diff >= 0.0 + except (TypeError, ValueError): + diff_ok = False + executed_ok = item.get("executed_backend") == backend + item_ok = item.get("status") == "success" + ok = source_ok and backend_ok and item_ok and executed_ok and diff_ok + checks = [ + _bool_check("source_status_success", source_ok), + _bool_check("backend_status_success", backend_ok), + _bool_check("primitive_status_success", item_ok), + _bool_check("executed_backend_matches_requested", executed_ok), + _bool_check("recorded_numpy_difference_finite", diff_ok), + ] + model_ids.add("PanelCovariancePrimitive") + runs.append( + { + "run_id": "", + "benchmark_session_id": f"{env_id}-panel-stage-c-pr126-validation", + "env_id": env_id, + "category_ids": ["panel"], + "model_id": "PanelCovariancePrimitive", + "case_id": _stable_id("case", "stage-c-primitive", primitive_name, scale["scale_key"]), + "method_config_id": _stable_id("method", "stage-c-public-primitive", primitive_name), + "variant": f"public-{primitive_name.replace('_', '-')}", + "penalty": None, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": backend, + "scale": dict(scale), + "parameters": { + "metric_scope": "public_primitive_physical_validation", + "measurement_git_sha": data.get("git_sha"), + "working_tree_clean": bool(data.get("working_tree_clean")), + "executed_backend": item.get("executed_backend"), + }, + "source": _source(filepath, _VALIDATION_PARSER), + "metrics": {"validation": _validation(ok, filepath, checks)}, + } + ) + + if len(runs) != 64: + raise ValueError(f"PR126 validation parser expected 64 rows, got {len(runs)}") + return runs, _models(model_ids), warnings + + +def parse_panel_stage_c_performance( + filepath: Path, env_id: str +) -> tuple[list[dict], list[dict], list[str]]: + data = json.loads(filepath.read_text(encoding="utf-8")) + if int(data.get("schema_version", -1)) != 2: + raise ValueError("PR126 Stage-C performance source requires schema_version=2") + if data.get("git_sha") != _MEASUREMENT_SHA: + raise ValueError("PR126 Stage-C performance source measurement SHA drifted") + if data.get("working_tree_clean") is not True: + raise ValueError("PR126 Stage-C performance source requires a clean measurement tree") + if data.get("benchmark") != "panel_stage_c_covariance_fit_overhead": + raise ValueError("PR126 Stage-C performance benchmark identity drifted") + if data.get("timing_scope") != "synchronized end-to-end estimator fit": + raise ValueError("PR126 Stage-C performance timing scope drifted") + if data.get("high_t_scale") != "10000x2x200": + raise ValueError("PR126 Stage-C high-T scale drifted") + + rows = data.get("rows", []) + if len(rows) != 58: + raise ValueError(f"PR126 Stage-C performance requires 58 rows, got {len(rows)}") + if {row.get("backend") for row in rows} != {"cupy", "torch"}: + raise ValueError("PR126 Stage-C performance requires CuPy and Torch rows") + + base_rows = [row for row in rows if row.get("scenario") == "base"] + expected_base = { + (backend, case_name, n_samples, n_features, n_times) + for backend in ("cupy", "torch") + for case_name in _BASE_CASES + for n_samples, n_features, n_times in _BASE_SCALES + } + actual_base = [ + ( + row.get("backend"), + row.get("case"), + int(row.get("n_samples", 0)), + int(row.get("n_features", 0)), + int(row.get("n_times", 0)), + ) + for row in base_rows + ] + if len(actual_base) != len(expected_base) or set(actual_base) != expected_base: + raise ValueError("PR126 Stage-C performance base matrix drifted") + + high_t = [row for row in rows if row.get("scenario") == "high_t_qs"] + expected_high_t = { + (backend, case_name, 10000, 2, 200) + for backend in ("cupy", "torch") + for case_name in _HIGH_T_CASES + } + actual_high_t = [ + ( + row.get("backend"), + row.get("case"), + int(row.get("n_samples", 0)), + int(row.get("n_features", 0)), + int(row.get("n_times", 0)), + ) + for row in high_t + ] + if len(actual_high_t) != len(expected_high_t) or set(actual_high_t) != expected_high_t: + raise ValueError("PR126 Stage-C performance high-T QS matrix drifted") + + output: list[dict] = [] + model_ids: set[str] = set() + for row in rows: + backend = row.get("backend") + case_name = str(row.get("case")) + scenario = str(row.get("scenario")) + if scenario not in {"base", "high_t_qs"}: + raise ValueError(f"unknown PR126 Stage-C performance scenario: {scenario!r}") + repeats = int(row.get("repeats", 0)) + samples = row.get("samples_seconds") + if repeats <= 0 or not isinstance(samples, list) or len(samples) != repeats: + raise ValueError("PR126 Stage-C timing samples/repeats contract failed") + numeric_samples = [float(value) for value in samples] + if any(not math.isfinite(value) or value <= 0.0 for value in numeric_samples): + raise ValueError("PR126 Stage-C timing samples must be finite and positive") + median = float(row.get("median_seconds")) + if not math.isfinite(median) or median <= 0.0: + raise ValueError("PR126 Stage-C timing median must be finite and positive") + expected_median = float(statistics.median(numeric_samples)) + if not math.isclose(median, expected_median, rel_tol=1e-12, abs_tol=1e-15): + raise ValueError("PR126 Stage-C reported median does not match raw samples") + + model_id = _model_id(case_name) + model_ids.add(model_id) + n_samples = int(row["n_samples"]) + n_features = int(row["n_features"]) + n_times = int(row["n_times"]) + scale = _scale( + n_samples, + n_features, + suffix=f"T={n_times}", + key_suffix=f"t{n_times}", + ) + output.append( + { + "run_id": "", + "benchmark_session_id": f"{env_id}-panel-stage-c-pr126-performance", + "env_id": env_id, + "category_ids": ["panel"], + "model_id": model_id, + "case_id": _stable_id( + "case", "stage-c-performance", case_name, scenario, + n_samples, n_features, n_times, + ), + "method_config_id": _stable_id("method", "stage-c-performance", case_name), + "variant": f"{case_name.replace('_', '-')}-{scenario.replace('_', '-')}", + "penalty": None, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": backend, + "scale": scale, + "parameters": { + "scenario": scenario, + "n_times": n_times, + "repeats": repeats, + "timing_scope": data.get("timing_scope"), + "input_residency": data.get("input_residency"), + "measurement_git_sha": data.get("git_sha"), + "working_tree_clean": True, + }, + "source": _source(filepath, _PERFORMANCE_PARSER), + "metrics": { + "timing": { + "fit_time_ms": round(median * 1000.0, 6), + "quality": "measured", + "source_file": filepath.name, + }, + "validation": { + "status": "pass", + "checks": [ + {"metric": "synchronized_timing", "status": "pass"}, + {"metric": "raw_samples_finite_positive", "status": "pass"}, + {"metric": "median_matches_raw_samples", "status": "pass"}, + ], + "quality": "reported", + "source_file": filepath.name, + }, + }, + } + ) + + return output, _models(model_ids), [] diff --git a/dev/benchmarks/frontend_data/registry.py b/dev/benchmarks/frontend_data/registry.py index 512a73041..ebf396104 100644 --- a/dev/benchmarks/frontend_data/registry.py +++ b/dev/benchmarks/frontend_data/registry.py @@ -23,6 +23,8 @@ parse_new_modules_with_anova_benchmark, parse_p2_benchmark, parse_panel_stage_b_physical_validation, + parse_panel_stage_c_physical_validation, + parse_panel_stage_c_performance, ) MINIMUM_DASHBOARD_SOURCE_DATE = date(2026, 6, 1) @@ -58,6 +60,8 @@ "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, + "panel_stage_c_physical_validation": parse_panel_stage_c_physical_validation, + "panel_stage_c_performance": parse_panel_stage_c_performance, } diff --git a/dev/benchmarks/frontend_sources.json b/dev/benchmarks/frontend_sources.json index ebaa06243..a87be8365 100644 --- a/dev/benchmarks/frontend_sources.json +++ b/dev/benchmarks/frontend_sources.json @@ -24,6 +24,11 @@ "label": "Tesla P100 PR #122 Panel Stage B validation \u2014 2026-08-09", "gpu": "Tesla P100-SXM2-16GB", "cpu": "x86_64" + }, + "remote-p100-pr126-20260810": { + "label": "Tesla P100 PR #126 Panel Stage C \u2014 2026-08-10", + "gpu": "Tesla P100-SXM2-16GB", + "cpu": "x86_64" } }, "frameworks": { @@ -102,6 +107,14 @@ "panel-stage-b-pr122-20260809": { "label": "Panel Stage B physical validation \u2014 PR #122 \u2014 2026-08-09", "env_id": "remote-p100-pr122-20260809" + }, + "panel-stage-c-pr126-validation-20260810": { + "label": "Panel Stage C physical validation \u2014 PR #126 \u2014 2026-08-10", + "env_id": "remote-p100-pr126-20260810" + }, + "panel-stage-c-pr126-performance-20260810": { + "label": "Panel Stage C synchronized performance \u2014 PR #126 \u2014 2026-08-10", + "env_id": "remote-p100-pr126-20260810" } }, "sources": [ @@ -255,6 +268,36 @@ "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." + }, + { + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "comparison_id": "panel-stage-c-pr126-validation-20260810", + "path": "results/pr126_p100/panel_stage_c_gpu_validation_aad53587.json", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c", + "parser": "panel_stage_c_physical_validation", + "parser_version": "1.0", + "env_id": "remote-p100-pr126-20260810", + "required": true, + "allowed_issue_codes": [], + "source_date": "2026-08-10", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "raw_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "provenance_note": "Current PR #126 Stage-C repaired exact-clean-head P100 correctness/backend-provenance evidence. Artifact repository commit fdf88e8990b30502958cc357099342d271792ec2; Git blob 4fc52f29021321a9d7b1f87fc76950c843ef4059; 26 estimator cases plus six direct public covariance primitives per CuPy/Torch backend, including full-rank ill-conditioned HC0/HC2/HC3/Driscoll-Kraay, with requested/executed backend identity and no numerical CPU fallback. The older c151550a and 9c0b3050 measurements remain immutable historical evidence." + }, + { + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "comparison_id": "panel-stage-c-pr126-performance-20260810", + "path": "results/pr126_p100/panel_stage_c_performance_aad53587.json", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6", + "parser": "panel_stage_c_performance", + "parser_version": "1.0", + "env_id": "remote-p100-pr126-20260810", + "required": true, + "allowed_issue_codes": [], + "source_date": "2026-08-10", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "raw_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "provenance_note": "Current PR #126 Stage-C repaired synchronized end-to-end P100 timing evidence. Artifact repository commit fdf88e8990b30502958cc357099342d271792ec2; Git blob fd7b06e0bb3a51e6a74e524e5bc059063b5f75eb; 58 synchronized rows cover three base scales plus the bounded N=10000, k=2, T=200 QS all-lag scenario on both CuPy and Torch. No speedup claim or CPU baseline is encoded. The older c151550a and 9c0b3050 timing artifacts remain immutable historical evidence." } ] } diff --git a/dev/benchmarks/validate_panel_stage_c_gpu.py b/dev/benchmarks/validate_panel_stage_c_gpu.py new file mode 100644 index 000000000..85c465942 --- /dev/null +++ b/dev/benchmarks/validate_panel_stage_c_gpu.py @@ -0,0 +1,501 @@ +#!/usr/bin/env python3 +"""Physical CuPy/Torch acceptance for Panel Tier-1 Stage C covariance. + +This is a correctness/backend-provenance gate, not a timing benchmark. It +compares every newly supported covariance integration against NumPy on the same +aligned panel while proving that explicit CuPy/Torch CUDA requests really +execute without CPU fallback. +""" + +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 _is_cupy_array, _is_torch_array, _to_numpy +from statgpu.panel import ( + BetweenOLS, + FirstDifferenceOLS, + PanelOLS, + PooledOLS, + RandomEffects, + clustered_covariance, + driscoll_kraay_covariance, +) +from statgpu.panel._covariance import ols_covariance + + +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=20260811, *, unbalanced=True): + rng = np.random.default_rng(seed) + n_entities, n_times = 10, 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)) + alpha = np.repeat(rng.normal(scale=0.4, size=n_entities), n_times) + tau = np.tile(np.linspace(-0.2, 0.25, n_times), n_entities) + y = 0.8 * X[:, 0] - 0.35 * X[:, 1] + alpha + 0.25 * tau + y += rng.normal(scale=0.22, size=entity.size) + if unbalanced: + keep = np.ones(entity.size, dtype=bool) + keep[[1, 10, 19, 37, 58, 71]] = False + X, y, entity, time = X[keep], y[keep], entity[keep], time[keep] + cluster_a = np.asarray([f"firm-{v}" for v in entity], dtype=object) + cluster_b = np.asarray([f"period-{v}" for v in time], dtype=object) + clusters = np.column_stack([cluster_a, cluster_b]) + return X.astype(np.float64), y.astype(np.float64), entity, time, clusters + + +def _ill_conditioned_inputs(seed=20260814): + rng = np.random.default_rng(seed) + n = 50 + x = rng.normal(size=n) + X = np.column_stack( + [np.ones(n), x, x + 1.0e-9 * rng.normal(size=n)] + ) + y = X @ np.array([0.35, 0.8, -0.45]) + rng.normal(scale=0.2, size=n) + params = np.linalg.lstsq(X, y, rcond=None)[0] + resid = y - X @ params + time = np.tile(np.arange(10), 5) + if np.linalg.matrix_rank(X) != 3 or np.linalg.cond(X) <= 1.0e8: + raise AssertionError("ill-conditioned physical fixture lost full-rank contract") + return X, resid, time + + +def _to_backend(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(backend): + return {"numpy": "cpu", "cupy": "cuda", "torch": "torch"}[backend] + + +def _backend_name(model): + executed = getattr(model, "_backend_name", None) + if executed is None: + raise AssertionError("fit did not persist executed backend provenance") + return executed + + +def _array(value): + return np.asarray(_to_numpy(value), dtype=np.float64) + + +def _array_backend_name(value): + if _is_cupy_array(value): + return "cupy" + if _is_torch_array(value): + return "torch" + return "numpy" + + +def _public_primitive_cases(X, y, entity, time, clusters, backend): + X_design = np.column_stack([np.ones(len(y)), X]) + params = np.linalg.lstsq(X_design, y, rcond=None)[0] + resid = y - X_design @ params + Xb, rb, _eb, _tb = _to_backend(X_design, resid, entity, time, backend) + + X_ill, resid_ill, time_ill = _ill_conditioned_inputs() + dummy_entity = np.arange(len(resid_ill), dtype=np.int64) + X_ill_b, resid_ill_b, _dummy_b, time_ill_b = _to_backend( + X_ill, resid_ill, dummy_entity, time_ill, backend + ) + return { + "cluster_group_debias": clustered_covariance( + Xb, rb, clusters[:, 0], group_debias=True + ), + "driscoll_kraay_qs": driscoll_kraay_covariance( + Xb, rb, time, bandwidth=2, kernel="qs" + ), + "ill_conditioned_hc0": ols_covariance( + X_ill_b, resid_ill_b, cov_type="hc0" + ), + "ill_conditioned_hc2": ols_covariance( + X_ill_b, resid_ill_b, cov_type="hc2" + ), + "ill_conditioned_hc3": ols_covariance( + X_ill_b, resid_ill_b, cov_type="hc3" + ), + "ill_conditioned_dk": driscoll_kraay_covariance( + X_ill_b, + resid_ill_b, + time_ill_b, + bandwidth=2, + kernel="bartlett", + ), + } + + +def _snapshot(model): + fit = model.fit_statistics_ + fit_payload = { + "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 tuple(float(v) for v in fit.f_df), + } + return { + "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_), + "covariance": _array(model._panel_cov_params_raw), + "nobs": int(model.nobs), + "df_resid": int(model.df_resid), + "fit_statistics": fit_payload, + "covariance_metadata": dict(getattr(model, "_covariance_metadata", {})), + } + + +def _fit_cases(X, y, entity, time, clusters, backend): + Xb, yb, eb, tb = _to_backend(X, y, entity, time, backend) + device = _device(backend) + cases = {} + + for cov in ("hc0", "hc2", "hc3"): + cases[f"pooled_{cov}"] = PooledOLS(cov_type=cov, device=device).fit( + Xb, yb, entity_ids=eb + ) + cases["pooled_cluster_one_way"] = PooledOLS( + cov_type="clustered", device=device + ).fit(Xb, yb, cluster=clusters[:, 0], entity_ids=eb) + cases["pooled_cluster_two_way_group_debias"] = PooledOLS( + cov_type="clustered", group_debias=True, device=device + ).fit(Xb, yb, cluster=clusters, entity_ids=eb) + cases["pooled_dk_bartlett"] = PooledOLS( + cov_type="dk", bandwidth=2, kernel="bartlett", device=device + ).fit(Xb, yb, entity_ids=eb, time_index=time) + cases["pooled_dk_qs"] = PooledOLS( + cov_type="dk", bandwidth=2, kernel="qs", device=device + ).fit(Xb, yb, entity_ids=eb, time_index=time) + cases["pooled_legacy_hac"] = PooledOLS( + cov_type="hac", bandwidth=2, device=device + ).fit(Xb, yb, entity_ids=eb, time_index=time) + + for cov in ("hc0", "hc2", "hc3"): + cases[f"panel_entity_{cov}"] = PanelOLS( + entity_effects=True, cov_type=cov, device=device + ).fit(Xb, yb, entity_ids=eb) + cases["panel_two_way_hc3"] = PanelOLS( + entity_effects=True, time_effects=True, cov_type="hc3", device=device + ).fit(Xb, yb, entity_ids=eb, time_ids=tb) + cases["panel_two_way_cluster_group_debias"] = PanelOLS( + entity_effects=True, + time_effects=True, + cov_type="clustered", + group_debias=True, + device=device, + ).fit(Xb, yb, entity_ids=eb, time_ids=tb, cluster=clusters) + cases["panel_two_way_dk"] = PanelOLS( + entity_effects=True, + time_effects=True, + cov_type="dk", + bandwidth=2, + device=device, + ).fit(Xb, yb, entity_ids=eb, time_ids=tb) + + Xc = np.column_stack([np.ones(len(y)), X]) + Xcb, ycb, ecb, tcb = _to_backend(Xc, y, entity, time, backend) + for cov in ("robust", "hc0", "hc2", "hc3"): + cases[f"random_effects_explicit_constant_{cov}"] = RandomEffects( + cov_type=cov, device=device + ).fit(Xcb, ycb, entity_ids=ecb) + cases["random_effects_cluster_two_way"] = RandomEffects( + cov_type="clustered", group_debias=True, device=device + ).fit(Xcb, ycb, entity_ids=ecb, cluster=clusters) + cases["random_effects_dk"] = RandomEffects( + cov_type="dk", bandwidth=2, kernel="parzen", device=device + ).fit(Xcb, ycb, entity_ids=ecb, time_ids=tcb) + + for cov in ("hc0", "hc2", "hc3"): + cases[f"between_{cov}"] = BetweenOLS(cov_type=cov, device=device).fit( + Xb, yb, entity_ids=eb + ) + cases[f"first_difference_{cov}"] = FirstDifferenceOLS( + cov_type=cov, device=device + ).fit(Xb, yb, entity_ids=eb, time_ids=tb) + + return cases + + +def _max_abs(actual, expected): + if actual.size == 0: + return 0.0 + return float(np.max(np.abs(actual - expected))) + + +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(reference, candidate, *, rtol, atol, label): + differences = {} + for field in ("coef", "bse", "tvalues", "pvalues", "conf_int", "covariance"): + np.testing.assert_allclose( + candidate[field], reference[field], rtol=rtol, atol=atol, err_msg=f"{label}.{field}" + ) + differences[field] = _max_abs(candidate[field], reference[field]) + for field in ("nobs", "df_resid"): + if candidate[field] != 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] + if field == "f_df": + if expected is None: + if actual is not None: + raise AssertionError(f"{label}.f_df expected None") + else: + np.testing.assert_allclose(actual, expected, rtol=0, atol=0) + else: + differences[f"fit_statistics.{field}"] = _scalar_diff( + actual, expected, rtol=rtol, atol=atol, label=f"{label}.fit_statistics.{field}" + ) + ref_meta = reference["covariance_metadata"] + cand_meta = candidate["covariance_metadata"] + if set(cand_meta) != set(ref_meta): + raise AssertionError( + f"{label}.covariance_metadata keys mismatch: " + f"{sorted(cand_meta)} != {sorted(ref_meta)}" + ) + for key, expected in ref_meta.items(): + actual = cand_meta[key] + metric = f"covariance_metadata.{key}" + if isinstance(expected, float): + differences[metric] = _scalar_diff( + actual, expected, rtol=rtol, atol=atol, label=f"{label}.{metric}" + ) + elif isinstance(expected, list) and any(isinstance(v, float) for v in expected): + np.testing.assert_allclose(actual, expected, rtol=rtol, atol=atol, err_msg=f"{label}.{metric}") + differences[metric] = _max_abs( + np.asarray(actual, dtype=np.float64), np.asarray(expected, dtype=np.float64) + ) + elif actual != expected: + raise AssertionError( + f"{label}.{metric}: {actual!r} != {expected!r}" + ) + else: + differences[metric] = 0.0 + 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("--expected-sha", required=True) + parser.add_argument("--backends", default="cupy,torch") + parser.add_argument("--rtol", type=float, default=5e-6) + parser.add_argument("--atol", type=float, default=5e-7) + args = parser.parse_args() + + backends = [item.strip() for item in args.backends.split(",") if item.strip()] + if not backends or any(item not in {"cupy", "torch"} for item 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:\n" + dirty) + + X, y, entity, time, clusters = _dataset() + reference_models = _fit_cases(X, y, entity, time, clusters, "numpy") + reference = {name: _snapshot(model) for name, model in reference_models.items()} + primitive_reference = { + name: _array(value) + for name, value in _public_primitive_cases( + X, y, entity, time, clusters, "numpy" + ).items() + } + required_public_primitives = { + "cluster_group_debias", + "driscoll_kraay_qs", + "ill_conditioned_hc0", + "ill_conditioned_hc2", + "ill_conditioned_hc3", + "ill_conditioned_dk", + } + if set(primitive_reference) != required_public_primitives: + raise AssertionError("NumPy public primitive acceptance matrix drifted") + + results = {} + for backend in backends: + models = _fit_cases(X, y, entity, time, clusters, backend) + payload = { + "status": "success", + "requested_backend": backend, + "cases": {}, + "public_primitives": {}, + } + if set(models) != set(reference): + raise AssertionError(f"{backend}: physical case set differs from NumPy reference") + for name, model in models.items(): + executed = _backend_name(model) + if executed != backend: + raise AssertionError(f"{name}: requested {backend}, executed {executed}") + snapshot = _snapshot(model) + differences = _compare( + reference[name], snapshot, rtol=args.rtol, atol=args.atol, label=name + ) + payload["cases"][name] = { + "status": "success", + "executed_backend": executed, + "max_abs_differences": differences, + "covariance_metadata": snapshot["covariance_metadata"], + } + primitive_values = _public_primitive_cases( + X, y, entity, time, clusters, backend + ) + if set(primitive_values) != required_public_primitives: + raise AssertionError( + f"{backend}: public primitive acceptance matrix drifted" + ) + for name, value in primitive_values.items(): + executed = _array_backend_name(value) + if executed != backend: + raise AssertionError( + f"public primitive {name}: requested {backend}, executed {executed}" + ) + actual = _array(value) + np.testing.assert_allclose( + actual, + primitive_reference[name], + rtol=args.rtol, + atol=args.atol, + err_msg=f"public primitive {name}", + ) + payload["public_primitives"][name] = { + "status": "success", + "executed_backend": executed, + "max_abs_difference": _max_abs(actual, primitive_reference[name]), + } + results[backend] = payload + + required_cases = { + "pooled_hc0", "pooled_hc2", "pooled_hc3", + "pooled_cluster_one_way", "pooled_cluster_two_way_group_debias", + "pooled_dk_bartlett", "pooled_dk_qs", "pooled_legacy_hac", + "panel_entity_hc0", "panel_entity_hc2", "panel_entity_hc3", "panel_two_way_hc3", + "panel_two_way_cluster_group_debias", "panel_two_way_dk", + "random_effects_explicit_constant_robust", "random_effects_explicit_constant_hc0", + "random_effects_explicit_constant_hc2", "random_effects_explicit_constant_hc3", + "random_effects_cluster_two_way", "random_effects_dk", + "between_hc0", "between_hc2", "between_hc3", + "first_difference_hc0", "first_difference_hc2", "first_difference_hc3", + } + if set(reference) != required_cases: + missing = sorted(required_cases - set(reference)) + unexpected = sorted(set(reference) - required_cases) + raise AssertionError( + "NumPy reference Stage-C physical matrix drifted: " + f"missing={missing}, unexpected={unexpected}" + ) + if len(reference) != 26: + raise AssertionError(f"expected 26 Stage-C physical cases, got {len(reference)}") + for backend, payload in results.items(): + if set(payload["cases"]) != required_cases: + missing = sorted(required_cases - set(payload["cases"])) + unexpected = sorted(set(payload["cases"]) - required_cases) + raise AssertionError( + f"{backend}: Stage-C physical matrix drifted: " + f"missing={missing}, unexpected={unexpected}" + ) + + output = { + "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}, + "dataset": { + "nobs": int(len(y)), + "n_entities": int(len(np.unique(entity))), + "n_times": int(len(np.unique(time))), + "n_features": int(X.shape[1]), + "unbalanced": True, + }, + "case_count_per_backend": len(reference), + "public_primitive_count_per_backend": len(required_public_primitives), + "backends": results, + } + args.out.parent.mkdir(parents=True, exist_ok=True) + args.out.write_text(json.dumps(output, indent=2) + "\n", encoding="utf-8") + print(json.dumps(output, indent=2)) + print(f"PASS — Panel Stage C physical GPU validation: {args.out}") + + +if __name__ == "__main__": + main() diff --git a/dev/plans/panel_p1_stage_c_covariance_plan.md b/dev/plans/panel_p1_stage_c_covariance_plan.md new file mode 100644 index 000000000..6c0310858 --- /dev/null +++ b/dev/plans/panel_p1_stage_c_covariance_plan.md @@ -0,0 +1,525 @@ +# Panel Tier-1 Stage C — covariance completion plan + +Issue: #93 +Base: PR #122 / merge commit `d5dd79956a17807b11b3c8ffdbd0b8686c34cc9e` +Branch: `agent/panel-p1-stage-c-covariance` + +## 1. Scope and impact classification + +Stage C completes the covariance/inference work promised by Issue #93 while preserving all Stage-A/Stage-B coefficient estimates, fitted values, predictions, default covariance behavior, diagnostic definitions, and strict-device semantics. + +Active impact axes: + +- **Public API** — covariance names/options expand, `RandomEffects` gains covariance configuration, and covariance metadata becomes more explicit. +- **Inference** — HC0/HC2/HC3, robust RandomEffects inference, Driscoll–Kraay, cluster corrections, standard errors, test statistics, p-values, confidence intervals, and covariance matrices. +- **Backend** — covariance bread/meat, leverage, grouped score accumulation, and kernel lag accumulation must remain NumPy/CuPy/Torch native. +- **Formula/data alignment** — cluster/time/entity metadata must follow Patsy missing-row filtering and estimator-specific ordering/transformation. +- **Benchmark/performance** — HC2/HC3 and Driscoll–Kraay add backend kernels/reductions; correctness precedes performance, but representative physical timing/memory evidence is required before Stage C is called complete. +- **Docs/artifacts** — EN/CN panel docs, changelogs, physical validation, benchmark evidence, and benchmark coverage metadata where applicable. + +Inactive axes: + +- **Loss / penalty / solver / CV** — covariance estimation does not alter an optimization objective, regularization path, solver, or tuning layer. + +Validation target: `remote-full` before Stage C is called COMPLETE. If the only missing gate is physical GPU/R evidence, the correct hard exit is `PARTIAL_REMOTE_PENDING`. + +## 2. Capability decisions + +| Model | backend | inference | formula | covariance work in Stage C | +| --- | --- | --- | --- | --- | +| `PanelOLS` | three-backend | supported | supported | preserve nonrobust/HC1/clustered; add HC0/HC2/HC3 and Driscoll–Kraay; explicit one-/two-way cluster correction contract | +| `RandomEffects` | three-backend | supported | supported | preserve nonrobust default; add HC0/HC1/HC2/HC3, one-/two-way clustered, and Driscoll–Kraay on quasi-demeaned GLS fit space | +| `PooledOLS` | three-backend | supported | supported | preserve nonrobust/HC1/clustered/row-HAC; add HC0/HC2/HC3 and Driscoll–Kraay; explicit cluster correction contract | +| `BetweenOLS` | three-backend | supported | supported | preserve nonrobust/HC1; add HC0/HC2/HC3 on entity-mean regression; no DK because the fit space has one row per entity rather than a time-indexed panel score process | +| `FirstDifferenceOLS` | three-backend | supported | supported | preserve nonrobust/HC1; add HC0/HC2/HC3 on the retained first-difference regression; no Stage-C DK until a gap-aware differenced-time score contract is separately specified | +| `FamaMacBeth` | three-backend | supported | supported | unchanged; beta-series covariance remains model-specific (`nonrobust` / `newey-west`) and is not routed through residual-OLS covariance | + +`CV` is non-tunable/not applicable for all touched capabilities. A covariance option is not declared supported until its NumPy/CuPy/Torch inference path is tested. + +## 3. Backward-compatibility contract + +Stage C is additive. + +1. `cov_type='nonrobust'` remains unchanged. +2. `cov_type='robust'` remains the historical **HC1** contract; it is not redefined. +3. `hc1` is an explicit alias normalized internally to canonical `robust`. +4. `PooledOLS(cov_type='hac')` remains the historical row-order Newey–West/Bartlett estimator; it is not renamed/reinterpreted as Driscoll–Kraay. +5. Existing clustered covariance remains un-debiased by default. `group_debias=True` is opt-in, so old numerical output does not change. +6. Stage-B classical Hausman remains restricted to matched nonrobust FE/RE covariance. Robust/HC/cluster/DK RE fits remain inapplicable to this classical Hausman path. +7. Existing `PanelOLS` legacy public residual-df/t-inference behavior remains frozen where Stage B froze it. New covariance modes have their own documented correction basis. +8. Coefficients, fitted values, variance components, theta, R², specification tests, formula parsing, and prediction semantics do not change solely because Stage C exists. + +Golden regression tests must freeze pre-Stage-C default covariance/inference outputs before dispatch changes. + +## 4. Public API contract + +### 4.1 Covariance names + +Where permitted by the estimator matrix, normalize: + +- `nonrobust` +- `robust` +- `hc0` +- `hc1 -> robust` +- `hc2` +- `hc3` +- `clustered` +- `hac` (legacy row-HAC only where already supported) +- `driscoll-kraay`, aliases `dk` and `kernel` + +Unsupported names fail precisely; there is no covariance fallback. + +### 4.2 Covariance options + +Shared names where meaningful: + +- `bandwidth: Optional[int] = None` +- `kernel: str = 'bartlett'` +- `group_debias: bool = False` + +`group_debias=True` with a non-cluster covariance raises a precise fit-time `ValueError`. Existing default-valued bandwidth/kernel constructor state remains inert where it historically was inert; old calls do not begin failing merely because default metadata exists. + +### 4.3 Positional compatibility + +Current `RandomEffects(alpha=0.05, device='auto', n_jobs=None)` positional meaning is frozen. New covariance arguments are keyword-only after existing parameters: + +```python +RandomEffects( + alpha=0.05, + device='auto', + n_jobs=None, + *, + cov_type='nonrobust', + bandwidth=None, + kernel='bartlett', + group_debias=False, +) +``` + +Other estimator constructors likewise append/make keyword-only new options rather than shifting old positional parameters. `get_params`, `set_params`, clone, and exact constructor identity are blocking tests. + +### 4.4 Fit-time metadata + +- one-way cluster: aligned 1-D labels (and historical `(n,1)` where accepted); +- two-way cluster: exactly two aligned cluster dimensions; +- `PanelOLS` DK uses existing `time_ids`; +- `PooledOLS` DK uses existing `time_index`; +- `RandomEffects.fit` adds `cluster=None`; existing `time_ids` is consumed only by DK; +- formula missing-row filtering must align cluster/time arrays through the shared side-array machinery; +- old RE nonrobust/HC calls with unused `time_ids` do not acquire a new rejection solely because Stage C exists; +- full numerical X/y/residual/score arrays are never copied to CPU for covariance; label metadata may be factorized on CPU. + +## 5. HC0 / HC1 / HC2 / HC3 + +All HC estimators are defined on the estimator's **actual numerical fit-space regression**, not on a reconstructed full dummy-variable regression. + +For fit-space design `Z`, residuals `e`, and `B=(Z'Z)^+`: + +```text +h_i = z_i' B z_i +HC0 meat = sum_i z_i z_i' e_i^2 +HC1 meat = HC0 meat * historical correction +HC2 meat = sum_i z_i z_i' e_i^2/(1-h_i) +HC3 meat = sum_i z_i z_i' e_i^2/(1-h_i)^2 +V = B * meat * B. +``` + +Fit spaces: + +- Pooled: level design including fitted intercept; +- PanelOLS: effect-transformed slope design; +- RandomEffects: Swamy–Arora quasi-demeaned `X_star`; +- Between: entity-mean design including intercept; +- FirstDifference: retained differenced design. + +This is documented as **transformed-fit-space HC2/HC3**. It is not claimed equal to full dummy-regression HC2/HC3. + +Implementation requirements: + +- compute `h_i` rowwise as `sum((Z @ B) * Z, axis=1)`, never an `n x n` hat matrix; +- use pseudoinverse consistently for supported rank-deficient fit spaces; +- keep leverage/score arrays backend-native; +- reject materially invalid leverage and any numerically unit leverage that makes HC2/HC3 undefined; tiny dimensionless roundoff outside `[0,1]` may be normalized with a machine-epsilon guard only; +- existing `robust` continues its historical estimator-specific HC1 correction unchanged. + +## 6. RandomEffects covariance + +Swamy–Arora estimation is untouched. All Stage-C covariance uses the already-computed quasi-demeaned regression: + +```text +score_it = x*_it e*_it. +``` + +- HC0/1/2/3 use `X_star`/`resid_gls`; +- clustered covariance groups transformed scores using aligned level-observation cluster labels; +- DK groups transformed scores by aligned time IDs; +- covariance choice never changes coefficients/variance components/theta; +- Stage-B fit statistics remain unchanged; +- robust RE fits are explicitly rejected by classical Stage-B Hausman. + +## 7. One-way/two-way cluster covariance + +Uncorrected: + +```text +S_g = sum_{i in g} z_i e_i +M_g = sum_g S_g S_g' +V_g = B M_g B +V_two_way = V_g1 + V_g2 - V_intersection. +``` + +With `group_debias=True`, multiply each one-way **meat component before inclusion-exclusion** by + +```text +c(G,n) = [G/(G-1)] * [(n-1)/n]. +``` + +For two-way clustering, cluster 1, cluster 2, and intersection each use their own group count. This matches linearmodels 7.0 group-debias semantics. + +Contracts: + +- default `False` reproduces existing statgpu cluster covariance exactly; +- no extra linearmodels `extra_df` scale is inserted into the legacy default cluster path; +- `group_debias=True` with fewer than two groups in any required component raises; +- paired intersection groups use exact paired-label factorization (`np.unique(..., axis=0)`/equivalent) or another proven collision-free representation; no overflow-prone ad-hoc encoding; +- numerical grouped scores stay on device; only labels/codes may use CPU metadata. + +## 8. Driscoll–Kraay + +Primary alignment: official `linearmodels==7.0` `DriscollKraay` source/docs. + +Aggregate fit-space scores by ordered observed time: + +```text +g_t = sum_i z_it e_it. +``` + +For a kernel weight vector `w_j`, define + +```text +M_DK = sum_t g_t g_t' + + sum_{j=1}^{T-1} w_j * sum_{t=j+1}^T + (g_t g_{t-j}' + g_{t-j} g_t'), +``` + +where kernels may set some `w_j=0`; the support is kernel-specific (Section 8.4). + +Let `B=(Z'Z)^+`, `n` be fit-space observations, `r=rank(Z)`, and `extra_df` be nuisance parameters outside columns of `Z`. + +### 8.1 Full-rank external contract + +For `rank(Z)=k_columns`, Stage C uses the debiased linearmodels-compatible scale + +```text +scale_DK = n/(n-extra_df-k_columns) +V_DK = scale_DK * B M_DK B. +``` + +This is algebraically equivalent to linearmodels 7.0's `xpxi=inv(Z'Z/n)`, grouped `cov_kernel`, `T/n`, and `_scale=n/(n-extra_df-k_columns)` with `debiased=True`. Full-rank tests compare the final covariance exactly within numerical tolerance. + +### 8.2 Rank-deficient statgpu extension + +linearmodels DK assumes invertible fit-space Gram. For a statgpu fit that validly reaches covariance with `r T-1`. Only observed lags +`1,...,T-1` can contribute, but Bartlett/Parzen still use the requested `bw` +in their weight denominator and QS keeps it as the smoothing scale. Stage C +does not silently replace an oversized bandwidth by `T-1`. +For this oversized edge, Bartlett/Parzen are a documented statgpu extension: +linearmodels 7.0 rejects its `bw+1` weight vector when it is longer than the +`T` grouped scores. Stage C instead evaluates the same kernel formula only on +observed lags. Oversized QS remains directly executable and is compared to +linearmodels 7.0 at the final-covariance level. + +Kernel aliases/formulas follow linearmodels: + +**Bartlett / Newey–West** + +```text +w_0=1, +w_j = 1 - j/(bw+1), j=1,...,min(bw,T-1), +w_j = 0 beyond bw. +``` + +**Parzen / Gallant** + +For `z_j=j/(bw+1)` and `j<=min(bw,T-1)`: + +```text +w_j = 1 - 6 z_j^2 + 6 z_j^3, z_j <= 1/2 +w_j = 2(1-z_j)^3, z_j > 1/2 +``` + +and zero beyond the cutoff. + +**Quadratic Spectral / QS / Andrews** + +QS is **not truncated at `bw`**. For all observed lags `j=1,...,T-1` when `bw>0`: + +```text +x_j = 6*pi*j/(5*bw) +w_j = 3/x_j^2 * (sin(x_j)/x_j - cos(x_j)), +w_0 = 1. +``` + +When `bw=0`, define `w_0=1` and `w_j=0` for `j>0` (no autocorrelation lags). Thus QS bandwidth is a smoothing scale while its lag support is all observed lags. The implementation and tests must not reuse a generic `range(1,bw+1)` loop for QS. + +Effective bandwidth/support and canonical kernel name are retained in auditable covariance metadata/test output. Invalid kernel names fail precisely. Legacy Pooled row-HAC remains Bartlett-only and does not inherit the new DK aliases. + +## 9. Small-sample and reference-distribution conventions + +- nonrobust keeps Student-t; +- historical robust/explicit hc1 keeps HC1 scaling and normal-reference inference; +- HC0/HC2/HC3, cluster, and DK use existing sandwich normal-reference inference; +- `group_debias` changes covariance magnitude only, not the reference distribution; +- DK always uses Section-8 df correction; +- legacy cluster gets no new model-df factor by default; +- Panel DK uses Stage-B standard effect rank while historical Panel robust remains frozen. + +External tests assert covariance/SE plus documented correction settings; covariance scaling is not changed merely to force p-values from a different reference distribution. + +## 10. Backend-native algorithm contract + +Numerical arrays kept on active NumPy/CuPy/Torch backend: + +- fit-space design/residuals; +- row scores/leverage; +- grouped score matrices; +- lag products; +- bread/meat/covariance until existing final inference conversion. + +Allowed CPU metadata: + +- cluster/entity/time labels; +- integer group codes/order; +- small scalar configuration and kernel-weight vectors. + +Codes/weights are transferred to device for numerical accumulation. No full numerical X/residual/score/leverage transfer is allowed. + +A single backend-neutral grouped-score primitive must serve cluster and DK paths and use NumPy add-at/equivalent, CuPy add-at/equivalent, and Torch scatter-add without fallback or Python observation loops. + +## 11. Estimator integration + +### PanelOLS + +- preserve existing defaults; +- HC2/3 use transformed design; +- cluster retains one-/two-way semantics plus `group_debias`; +- DK uses aligned `time_ids` and Stage-B standard effect rank; +- entity-only, time-only, and two-way FE are supported if df is valid; +- all non-nonrobust covariance remains inapplicable to classical Hausman. + +### RandomEffects + +- keyword-only covariance constructor config; +- add `cluster=None` to fit side-array alignment; +- shared inference receives `X_star`/GLS residuals; +- DK consumes time IDs only when selected; +- explicit-constant and unbalanced covariance paths are required tests. + +### PooledOLS + +- add HC0/2/3 and DK; +- DK consumes `time_index` by group, not legacy HAC row-order formula; +- preserve BP-LM/entity diagnostic alignment. + +### BetweenOLS / FirstDifferenceOLS + +- add HC0/2/3 only; +- preserve transform/coefficient/robust semantics; +- reject DK/cluster absent a separate reviewed contract. + +### FamaMacBeth + +- no residual-sandwich changes; regression-freeze existing covariance. + +## 12. External alignment + +### linearmodels==7.0 + +Executable aligned cases: + +- Pooled robust/cluster/DK; +- Panel cluster group-debias primitive on same transformed design and DK with standard effect rank; +- RandomEffects robust/cluster/DK including explicit constant/unbalanced; +- DK full-rank scale, default/explicit bandwidth, Bartlett/Parzen/QS weights/support; +- cluster group-debias coefficient and two-way inclusion-exclusion. + +Tests state linearmodels `debiased`, `extra_df`, `group_debias`, clusters, kernel, bandwidth, effects, and intercept. Legacy statgpu corrections that intentionally differ are compared through the same transformed primitive or documented ratio, not “fixed” by breaking compatibility. + +### HC2/HC3 + +Primary baselines: + +1. direct analytic sandwich; +2. statsmodels OLS robust covariance on exactly the same transformed fit-space design/residuals where executable. + +Do not compare absorbed FE HC2/3 to a literal full-dummy HC2/3 and force equality. + +R `plm`/`sandwich` and Stata/fixest definitions are documentation/remote references where useful; unavailable R is remote pending rather than permission to weaken Python/analytic gates. + +## 13. Tests + +### Primitive tests + +- HC0/HC1 scale; +- HC2/3 leverage and unit-leverage failure; +- rank-deficient pseudoinverse; +- one-/two-way cluster and intersection; +- group-debias factors and one-group errors; +- exact pair factorization; +- DK time aggregation/full-rank scale/rank-deficient extension; +- Bartlett/Parzen/QS exact weights and QS all-lag support; +- bandwidth default/zero/oversized/validation; +- unsorted/repeated/unbalanced time labels. + +### Estimator tests + +For every supported estimator/covariance family: + +- coefficients invariant to covariance selection; +- covariance/BSE/t-or-z/p/CI consistent; +- NumPy analytic/external precision; +- maintained Torch CPU where used by project gates; +- CuPy/Torch physical CUDA parity; +- explicit backend provenance/no fallback; +- formula vs array parity and missing-row metadata alignment; +- intercept/categorical/interaction cases where existing formula API supports them. + +### Compatibility tests + +- Stage-B default inference frozen; +- `robust == hc1 == historical HC1`; +- Pooled legacy `hac` frozen; +- FamaMacBeth covariance frozen; +- Stage-B Hausman/pooling/BP/fit statistics unchanged for equivalent fits. + +### Invalid tests + +- unsupported covariance; +- DK missing time / <2 periods / non-orderable labels; +- invalid bandwidth/kernel; +- malformed cluster dimensions; +- group debias too few groups/non-cluster use; +- HC2/3 undefined leverage; +- requested GPU backend unavailable. + +## 14. Physical GPU validation + +Add `dev/benchmarks/validate_panel_stage_c_gpu.py` as correctness/provenance only. + +Every new public covariance integration reaches both CuPy and Torch CUDA at least once. +The exported covariance primitives also receive direct-call CuPy/Torch acceptance with `xp` omitted, proving public backend auto-detection rather than only estimator-mediated execution. + +Minimum per backend: + +- Pooled: HC0/2/3, one-way cluster, DK Bartlett, legacy HAC regression; +- Panel: entity FE HC0/2/3, two-way FE HC2 or HC3, two-way group-debiased cluster, DK with effect-rank scaling; +- RandomEffects: HC0/1/2/3 including explicit constant/unbalanced, cluster, DK; +- Between: HC0/2/3; +- FirstDifference: HC0/2/3; +- at least one DK Parzen or QS explicit-bandwidth case, with QS all-lag execution physically covered; +- deliberately permuted/formula-equivalent metadata-order fixture where feasible. + +Record exact SHA/clean tree, requested/executed backend, covariance/SE/t/p/CI vs NumPy, coefficient and Stage-B-stat invariance, covariance config/effective bandwidth/support/group counts/rank extension, and environment/GPU metadata. + +A validator change after an accepted artifact invalidates acceptance for the changed validator contract per `RELEASING.md`. + +## 15. Performance gate + +Add a bounded synchronized Stage-C covariance benchmark. + +Questions: + +- HC2/3 avoids `O(n^2)` hat matrix and scales as row leverage + `k x k` operations; +- cluster/DK uses grouped backend reductions, not observation Python loops/full host numerical transfer; +- QS all-lag cost is reported at representative T and does not accidentally become `O(n^2)` in observations; the default runner includes a bounded same-order `N=10,000`, `k=2`, `T=200` high-T QS scenario in addition to the `T=20` base cases; +- GPU metadata conversion/synchronization is not transfer-dominated at target sizes. + +No speedup claim is planned. Performance becomes blocking only for material regression/pathological complexity/transfer dominance. Optimization budget: one profile, at most two algorithmic/kernel attempts, one rebenchmark each. Timing JSON remains separate from correctness evidence. + +## 16. Docs/artifacts + +Update EN first then CN: + +- `docs/en/models/panel.md`, `docs/cn/models/panel.md`; +- root + detailed EN/CN changelogs; +- docstrings/API examples; +- coverage/catalog/frontend only if physical Stage-C evidence is promoted; +- physical validation review record after remote acceptance. + +Docs explicitly state HC fit-space semantics, robust==HC1, legacy HAC vs DK, DK exact scaling/time/kernel/QS support, cluster group-debias, normal vs t references, RE quasi-demeaned scores, no fallback, and unsupported combinations. + +## 17. Implementation sequence + +1. Freeze Stage-B inference golden outputs. +2. Add covariance-name normalization, grouped-score primitive, HC leverage/meat, kernel weights. +3. Implement HC0/2/3 preserving robust HC1. +4. Harden cluster metadata and group-debias. +5. Implement DK exact scaling and kernel-specific support. +6. Integrate Pooled/Panel. +7. Integrate RE quasi-demeaned covariance. +8. Integrate Between/FD HC; freeze FMB. +9. Add analytic/statsmodels + pinned linearmodels 7.0 tests. +10. Add maintained Torch and complete physical CUDA runner contract. +11. Add performance benchmark/schema tests. +12. Run targeted/full hosted gates. +13. Run `.claude/skills/code-review.md` auto-fix; repeat until no local CRITICAL/HIGH/relevant MEDIUM. +14. Run exact-clean-head physical GPU and remote/external gates. +15. Promote evidence only after physical acceptance; rerun exact-final hosted gates and perform a fresh non-inherited final review. + +## 18. Acceptance checklist + +- [ ] Stage-B default covariance/inference preserved. +- [ ] HC0/1/2/3 transformed-fit-space semantics tested. +- [ ] RE HC/cluster/DK works without coefficient/variance-component drift. +- [ ] DK full-rank covariance matches linearmodels 7.0; rank-deficient behavior is explicitly a statgpu extension. +- [ ] Bartlett/Parzen/QS kernel weights and QS all-observed-lag support match the pinned definition. +- [ ] Pooled legacy row-HAC distinct/unchanged. +- [ ] Cluster one-/two-way and group-debias backward-compatible. +- [ ] Every supported new public covariance works NumPy/CuPy/Torch without fallback. +- [ ] Physical CUDA includes Pooled/Panel/RE/Between/FD new HC integrations plus cluster and DK on both GPU backends. +- [ ] No full GPU numerical host copy for covariance accumulation. +- [ ] Formula/missing-row metadata alignment tested. +- [ ] Analytic/statsmodels/linearmodels comparisons pass where definitionally comparable. +- [ ] Stage-B diagnostics/fit stats regression-clean. +- [ ] EN/CN docs/changelogs synchronized. +- [ ] Performance gate has no material unresolved regression. +- [ ] Exact-head hosted tests/compatibility/release/frontend gates pass. +- [ ] Exact-clean-head physical Stage-C CuPy/Torch validation passes and immutable evidence is recorded. +- [ ] Fresh final review has zero unresolved CRITICAL/HIGH/relevant MEDIUM. + +## 19. Non-goals + +No robust auxiliary Hausman, cluster t/F finite-group reference distribution, generic second covariance-debias API, weights, Panel IV/GMM, HDFE absorb, DID/event study, dynamic panel, FamaMacBeth redesign, PCSE, or Conley/spatial HAC. Any such addition requires a separate reviewed statistical/API contract. \ No newline at end of file diff --git a/dev/reviews/pr126_physical_gpu_validation.md b/dev/reviews/pr126_physical_gpu_validation.md new file mode 100644 index 000000000..b8da66642 --- /dev/null +++ b/dev/reviews/pr126_physical_gpu_validation.md @@ -0,0 +1,53 @@ +# PR #126 Panel Stage C physical GPU validation + +## Current physical acceptance status + +**PHYSICAL_GPU_ACCEPTED** for the repaired numerical/validator contract. + +Fresh Tesla P100 evidence was measured from exact clean implementation SHA `aad53587c9611da0e71a676e86ef32d9f6403f5c`. The subsequent artifact commit `fdf88e8990b30502958cc357099342d271792ec2` adds only the two raw evidence files; the canonical-promotion commits change parser/manifest/coverage/tests/docs/generated benchmark assets only. They do not change `statgpu/panel/**`, `dev/benchmarks/validate_panel_stage_c_gpu.py`, or `dev/benchmarks/benchmark_panel_stage_c_covariance.py`. Therefore the measurement remains applicable under `RELEASING.md`. + +## Correctness and backend-provenance evidence + +- path: `results/pr126_p100/panel_stage_c_gpu_validation_aad53587.json` +- measurement SHA: `aad53587c9611da0e71a676e86ef32d9f6403f5c` +- artifact repository commit: `fdf88e8990b30502958cc357099342d271792ec2` +- Git blob: `4fc52f29021321a9d7b1f87fc76950c843ef4059` +- SHA-256: `aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c` +- GPU: Tesla P100-SXM2-16GB +- result: CuPy 32/32 and Torch 32/32 = 26 estimator covariance cases + 6 direct public primitives per backend +- direct primitives: `cluster_group_debias`, `driscoll_kraay_qs`, `ill_conditioned_hc0`, `ill_conditioned_hc2`, `ill_conditioned_hc3`, `ill_conditioned_dk` +- requested backend equals the backend persisted at the numerical fit boundary; no numerical CPU fallback was observed + +## Synchronized performance evidence + +- path: `results/pr126_p100/panel_stage_c_performance_aad53587.json` +- measurement SHA: `aad53587c9611da0e71a676e86ef32d9f6403f5c` +- artifact repository commit: `fdf88e8990b30502958cc357099342d271792ec2` +- Git blob: `fd7b06e0bb3a51e6a74e524e5bc059063b5f75eb` +- SHA-256: `99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6` +- GPU: Tesla P100-SXM2-16GB for both CuPy and Torch +- rows: 58 = 54 base rows + 4 high-T QS rows +- timing scope: synchronized end-to-end estimator fit +- high-T scenario: `N=10,000`, `k=2`, `T=200` +- no speedup claim or CPU-baseline claim is made + +## Canonical promotion audit + +The fresh evidence is now the registered Stage-C canonical source contract: + +- correctness source: `panel-stage-c-validation-pr126-20260810-aab3ac61315b`; +- performance source: `panel-stage-c-performance-pr126-20260810-99208f9276b9`; +- the physical parser expects 26 estimator cases plus all 6 direct primitives and emits 64 validation rows across CuPy/Torch; +- the canonical benchmark bundle contains 1984 runs after adding the eight newly promoted primitive rows; +- recorded maximum absolute differences are treated as finite diagnostics, while the physical runner's `status=success` remains authoritative for its `rtol+atol` NumPy parity check because the artifact does not store the reference magnitudes needed to reconstruct the relative-tolerance term; +- the prior `c151550a...` and `9c0b3050...` artifacts remain immutable historical/non-current evidence; +- deterministic benchmark frontend assets were regenerated after promotion, and temporary promotion helpers are absent from the final tree; +- the promotion audit also verified and restored the pre-existing PR #122 canonical SHA-256 assertion after a broad run-count replacement accidentally touched the `1976` digit sequence inside that immutable hash; no Stage-B source, parser, or artifact content was changed. + +## Superseded historical evidence + +The prior `c151550a...` and `9c0b3050...` correctness/performance artifacts remain immutable audit history but are not current acceptance sources. The current canonical source contract is the fresh `aad53587...` measurement above. + +## Merge-readiness boundary + +The physical gate is closed. Merge readiness still requires all permanent hosted workflows to be green on the final metadata/promotion head and a fresh review with no unresolved CRITICAL/HIGH/relevant-MEDIUM finding. diff --git a/dev/tests/test_benchmark_catalog.py b/dev/tests/test_benchmark_catalog.py index 56729b848..3362a35e3 100644 --- a/dev/tests/test_benchmark_catalog.py +++ b/dev/tests/test_benchmark_catalog.py @@ -95,6 +95,19 @@ def test_catalog_retains_distinct_noncanonical_dispositions(entries): assert panel_raw["statistical_alignment_status"] == "accepted" assert panel_raw["issue"] == "#93" + stage_c_validation = next( + entry for entry in entries + if entry["path"] == "results/pr126_p100/panel_stage_c_gpu_validation_aad53587.json" + ) + stage_c_performance = next( + entry for entry in entries + if entry["path"] == "results/pr126_p100/panel_stage_c_performance_aad53587.json" + ) + assert stage_c_validation["classification"] == "registered_canonical" + assert stage_c_validation["source_id"] == "panel-stage-c-validation-pr126-20260810-aab3ac61315b" + assert stage_c_performance["classification"] == "registered_canonical" + assert stage_c_performance["source_id"] == "panel-stage-c-performance-pr126-20260810-99208f9276b9" + def test_coverage_matrix_is_referentially_complete(coverage_matrix, manifest): from dev.benchmarks.frontend_data.catalog import validate_coverage_matrix @@ -111,6 +124,8 @@ 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-2056f836bfe2", + "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "panel-stage-c-performance-pr126-20260810-99208f9276b9", ] assert rows["distribution-api"]["issue"] == "#101" assert rows["feature-selection-knockoff"]["issue"] == "#103" @@ -134,9 +149,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"]) == 11 - assert inventory["available_registered_sources"] == 11 - assert inventory["parsed_registered_sources"] == 11 + assert inventory["registered_sources"] == len(manifest["sources"]) == 13 + assert inventory["available_registered_sources"] == 13 + assert inventory["parsed_registered_sources"] == 13 assert inventory["eligible_sources"] == ( inventory["registered_sources"] + inventory["eligible_unregistered_sources"] @@ -198,3 +213,31 @@ def test_new_unmatched_artifact_is_not_silently_eligible(tmp_path, catalog, mani assert discovered[0]["classification"] == "not_canonical_ready" assert discovered[0]["canonical_eligible"] is False assert discovered[0]["issue"] == "#100" + + +def test_stage_c_superseded_artifacts_remain_historical(entries): + old_validation = next( + entry for entry in entries + if entry["path"] == "results/pr126_p100/panel_stage_c_gpu_validation_9c0b3050.json" + ) + old_performance = next( + entry for entry in entries + if entry["path"] == "results/pr126_p100/panel_stage_c_performance_9c0b3050.json" + ) + assert old_validation["classification"] == "historical_or_excluded" + assert old_validation["registered"] is False + assert old_performance["classification"] == "historical_or_excluded" + assert old_performance["registered"] is False + + prior_validation = next( + entry for entry in entries + if entry["path"] == "results/pr126_p100/panel_stage_c_gpu_validation_c151550a.json" + ) + prior_performance = next( + entry for entry in entries + if entry["path"] == "results/pr126_p100/panel_stage_c_performance_c151550a.json" + ) + assert prior_validation["classification"] == "historical_or_excluded" + assert prior_validation["registered"] is False + assert prior_performance["classification"] == "historical_or_excluded" + assert prior_performance["registered"] is False diff --git a/dev/tests/test_benchmark_frontend_data.py b/dev/tests/test_benchmark_frontend_data.py index 968270b91..57e5d1071 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"]) == 11 + assert len(manifest["sources"]) == 13 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"] == 11 - assert report["files_parsed"] == 11 - assert inventory["registered_sources"] == 11 - assert inventory["available_sources"] == 11 - assert inventory["parsed_sources"] == 11 + assert report["files_seen"] == 13 + assert report["files_parsed"] == 13 + assert inventory["registered_sources"] == 13 + assert inventory["available_sources"] == 13 + assert inventory["parsed_sources"] == 13 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 4ee720b8c..c62de7272 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"] == 11 + assert len(registered) == inventory["registered_sources"] == 13 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"] == 11 - assert serialized["parsed_registered_sources"] == 11 + assert serialized["available_registered_sources"] == 13 + assert serialized["parsed_registered_sources"] == 13 # Old Python callers can still read the two non-semantic aliases without # reintroducing those keys into the published JSON contract. - assert inventory["available_sources"] == 11 - assert inventory["parsed_sources"] == 11 + assert inventory["available_sources"] == 13 + assert inventory["parsed_sources"] == 13 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 d77c40a9f..93c1982fd 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"]) == 11 + assert len(manifest["sources"]) == 13 manifest_dates = { source["source_id"]: date.fromisoformat(source["source_date"]) @@ -410,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"]) == 1862 - assert report["runs_generated"] == 1862 + assert len(output["runs"]) == 1984 + assert report["runs_generated"] == 1984 def test_missing_domain_sources_are_manifest_registered(canonical_output): diff --git a/dev/tests/test_panel_formula.py b/dev/tests/test_panel_formula.py index 6826f4552..4d9c9e30e 100644 --- a/dev/tests/test_panel_formula.py +++ b/dev/tests/test_panel_formula.py @@ -42,7 +42,7 @@ def panel_df(): @pytest.fixture def panel_arrays(panel_df): - """Extract arrays from the panel DataFrame.""" + """Extract arrays from the panel DataFrame for testing.""" return { 'X': panel_df[['x1', 'x2']].values, 'y': panel_df['y'].values, @@ -180,7 +180,6 @@ def test_summary_has_feature_names(self, panel_df): m = PanelOLS() m.fit(formula="y ~ x1 + x2 | entity + time", data=panel_df) s = m.summary() - # Check that feature names are available assert hasattr(s, 'coef') def test_no_formula_backward_compat(self, panel_arrays): @@ -201,17 +200,35 @@ def test_no_formula_backward_compat(self, panel_arrays): class TestRandomEffectsFormula: def test_pipe_syntax(self, panel_df, panel_arrays): - """y ~ x1 + x2 | entity should match array interface.""" + """Implicit formula intercept matches an explicit constant array model.""" m_formula = RandomEffects() m_formula.fit(formula="y ~ x1 + x2 | entity", data=panel_df) + X_with_constant = np.column_stack( + [np.ones(len(panel_arrays['y'])), panel_arrays['X']] + ) m_array = RandomEffects() m_array.fit( - X=panel_arrays['X'], y=panel_arrays['y'], + X=X_with_constant, y=panel_arrays['y'], entity_ids=panel_arrays['entity_ids'], ) assert_allclose(m_formula.coef_, m_array.coef_, rtol=1e-6) + assert m_formula._feature_names == ["Intercept", "x1", "x2"] + + def test_formula_explicit_no_intercept_matches_no_constant_array( + self, panel_df, panel_arrays + ): + m_formula = RandomEffects() + m_formula.fit(formula="y ~ 0 + x1 + x2 | entity", data=panel_df) + + m_array = RandomEffects() + m_array.fit( + X=panel_arrays['X'], y=panel_arrays['y'], + entity_ids=panel_arrays['entity_ids'], + ) + assert_allclose(m_formula.coef_, m_array.coef_, rtol=1e-6) + assert m_formula._feature_names == ["x1", "x2"] def test_predict_with_dataframe(self, panel_df): m = RandomEffects() diff --git a/dev/tests/test_panel_stage_c_api_formula.py b/dev/tests/test_panel_stage_c_api_formula.py new file mode 100644 index 000000000..f8b27605a --- /dev/null +++ b/dev/tests/test_panel_stage_c_api_formula.py @@ -0,0 +1,313 @@ +"""Stage-C public API, formula alignment, and metadata-order contracts.""" + +from __future__ import annotations + +import numpy as np +import pytest +from numpy.testing import assert_allclose + +pd = pytest.importorskip("pandas") +patsy = pytest.importorskip("patsy") + +from statgpu.inference._results import ParameterInferenceResult +from statgpu.panel import BetweenOLS, PanelOLS, PooledOLS, RandomEffects +from statgpu.panel._covariance import driscoll_kraay_covariance + + +def _frame(seed=12800): + rng = np.random.default_rng(seed) + n_entities, n_times = 8, 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) + z = rng.normal(size=entity.size) + alpha = np.repeat(rng.normal(scale=0.4, size=n_entities), n_times) + y = 0.7 * x - 0.25 * z + alpha + rng.normal(scale=0.2, size=entity.size) + return pd.DataFrame( + { + "y": y, + "x": x, + "z": z, + "entity": entity, + "time": time, + } + ) + + +def test_random_effects_stage_c_options_do_not_shift_old_positional_arguments(): + model = RandomEffects(0.1, "cpu", 3, cov_type="hc2", bandwidth=2) + assert model.alpha == 0.1 + assert str(model.device).lower().endswith("cpu") + assert model.n_jobs == 3 + assert model.cov_type == "hc2" + assert model.bandwidth == 2 + params = model.get_params() + assert params["alpha"] == 0.1 + assert params["cov_type"] == "hc2" + assert params["bandwidth"] == 2 + assert params["group_debias"] is False + + +def test_random_effects_hc1_alias_preserves_raw_constructor_identity_and_runtime_robust_contract(): + model = RandomEffects(cov_type="hc1") + assert model.cov_type == "hc1" + assert model._cov_type == "robust" + params = model.get_params() + assert params["cov_type"] == "hc1" + + +def test_panel_dk_formula_missing_rows_matches_explicit_filtered_array_fit(): + data = _frame(12801) + data.loc[[3, 17], "x"] = np.nan + formula_model = PanelOLS( + entity_effects=True, + time_effects=True, + cov_type="dk", + bandwidth=2, + ).fit(formula="y ~ x + z | entity + time", data=data) + + keep = data[["y", "x", "z"]].notna().all(axis=1).to_numpy() + X = data.loc[keep, ["x", "z"]].to_numpy() + y = data.loc[keep, "y"].to_numpy() + entity = data.loc[keep, "entity"].to_numpy() + time = data.loc[keep, "time"].to_numpy() + array_model = PanelOLS( + entity_effects=True, + time_effects=True, + cov_type="dk", + bandwidth=2, + ).fit(X, y, entity_ids=entity, time_ids=time) + + assert_allclose(formula_model.coef_, array_model.coef_, rtol=2e-12, atol=2e-13) + assert_allclose(formula_model.bse_, array_model.bse_, rtol=2e-11, atol=2e-13) + assert formula_model._covariance_metadata["n_periods"] == len(np.unique(time)) + + +def test_pooled_two_way_string_clusters_follow_formula_missing_row_filter(): + data = _frame(12802) + data["firm_cluster"] = np.array([f"firm-{i}" for i in data["entity"]]) + data["calendar_cluster"] = np.array([f"t-{i}" for i in data["time"]]) + clusters = data[["firm_cluster", "calendar_cluster"]].to_numpy(dtype=object) + data.loc[[5, 24], "z"] = np.nan + + formula_model = PooledOLS( + cov_type="clustered", + group_debias=True, + ).fit( + formula="y ~ x + z", + data=data, + cluster=clusters, + ) + + keep = data[["y", "x", "z"]].notna().all(axis=1).to_numpy() + array_model = PooledOLS( + cov_type="clustered", + group_debias=True, + ).fit( + data.loc[keep, ["x", "z"]].to_numpy(), + data.loc[keep, "y"].to_numpy(), + cluster=clusters[keep], + ) + assert_allclose(formula_model.coef_, array_model.coef_, rtol=2e-12, atol=2e-13) + assert_allclose(formula_model.bse_, array_model.bse_, rtol=2e-11, atol=2e-13) + assert formula_model._covariance_metadata["cluster_dimensions"] == 2 + + +def test_random_effects_dk_formula_metadata_alignment_matches_constant_array_fit(): + data = _frame(12803) + data.loc[[7, 20], "x"] = np.nan + formula_model = RandomEffects(cov_type="dk", bandwidth=2).fit( + formula="y ~ x + z | entity + time", + data=data, + ) + + keep = data[["y", "x", "z"]].notna().all(axis=1).to_numpy() + X = np.column_stack( + [ + np.ones(int(np.sum(keep))), + data.loc[keep, ["x", "z"]].to_numpy(), + ] + ) + array_model = RandomEffects(cov_type="dk", bandwidth=2).fit( + X, + data.loc[keep, "y"].to_numpy(), + entity_ids=data.loc[keep, "entity"].to_numpy(), + time_ids=data.loc[keep, "time"].to_numpy(), + ) + assert_allclose(formula_model.coef_, array_model.coef_, rtol=2e-12, atol=2e-13) + assert_allclose(formula_model.bse_, array_model.bse_, rtol=2e-11, atol=2e-13) + summary = formula_model.summary() + assert summary.feature_names == ["Intercept", "x", "z"] + + +def test_panel_summary_labels_normal_reference_as_z_and_nonrobust_as_t(): + data = _frame(128036) + X = data[["x", "z"]].to_numpy() + y = data["y"].to_numpy() + + robust = PooledOLS(cov_type="hc0").fit(X, y) + robust_text = str(robust.summary()) + assert "P>|z|" in robust_text + assert "P>|t|" not in robust_text + assert robust._inference_result.statistic_name == "z" + + nonrobust = PooledOLS(cov_type="nonrobust").fit(X, y) + nonrobust_text = str(nonrobust.summary()) + assert "P>|t|" in nonrobust_text + assert "P>|z|" not in nonrobust_text + assert nonrobust._inference_result.statistic_name == "t" + + + +@pytest.mark.parametrize("estimator", [PooledOLS, BetweenOLS]) +def test_formula_added_constant_keeps_intercept_in_summary_and_inference_names(estimator): + data = _frame(128035) + kwargs = {} + if estimator is BetweenOLS: + kwargs["entity_ids"] = data["entity"].to_numpy() + model = estimator(cov_type="hc0").fit( + formula="y ~ x + z", + data=data, + **kwargs, + ) + + expected_names = ["Intercept", "x", "z"] + summary = model.summary() + assert summary.feature_names == expected_names + assert len(summary.feature_names) == len(summary.coef) == len(model.coef_) + assert model._feature_names == expected_names + assert model._inference_result.feature_names == expected_names + + + +def test_random_effects_formula_matches_patsy_categorical_interaction_transform_matrix(): + data = _frame(128034) + data["group"] = pd.Categorical( + np.where( + data["time"].to_numpy() % 3 == 0, + "base", + np.where(data["time"].to_numpy() % 3 == 1, "mid", "high"), + ), + categories=["base", "mid", "high"], + ) + main_formula = "y ~ x * C(group) + I(z ** 2)" + y_design, X_design = patsy.dmatrices( + main_formula, data, return_type="dataframe" + ) + + formula_model = RandomEffects().fit( + formula=f"{main_formula} | entity", + data=data, + ) + array_model = RandomEffects().fit( + X_design.to_numpy(), + y_design.iloc[:, 0].to_numpy(), + entity_ids=data["entity"].to_numpy(), + ) + + expected_names = list(X_design.design_info.column_names) + assert formula_model._feature_names == expected_names + assert "Intercept" in expected_names + assert "C(group)[T.mid]" in expected_names + assert "C(group)[T.high]" in expected_names + assert "x:C(group)[T.mid]" in expected_names + assert "x:C(group)[T.high]" in expected_names + assert "I(z ** 2)" in expected_names + assert_allclose(formula_model.coef_, array_model.coef_, rtol=2e-12, atol=2e-13) + assert_allclose(formula_model.bse_, array_model.bse_, rtol=2e-11, atol=2e-13) + assert_allclose(formula_model.pvalues_, array_model.pvalues_, rtol=2e-11, atol=2e-13) + + expected_prediction = X_design.to_numpy() @ np.asarray(formula_model.coef_) + assert_allclose( + formula_model.predict(data), + expected_prediction, + rtol=2e-12, + atol=2e-13, + ) + + +@pytest.mark.parametrize( + "column,expected_name", + [("entity", "entity_ids"), ("time", "time_ids")], +) +def test_pipe_formula_rejects_missing_fixed_effect_labels(column, expected_name): + data = _frame(128031) + data.loc[5, column] = np.nan + with pytest.raises( + ValueError, + match=rf"{expected_name}.*missing or non-finite", + ): + PanelOLS(entity_effects=True, time_effects=True).fit( + formula="y ~ x + z | entity + time", + data=data, + ) + + +def test_formula_aligned_cluster_rejects_missing_labels(): + data = _frame(128032) + clusters = data["entity"].astype(object).to_numpy().copy() + clusters[4] = None + with pytest.raises(ValueError, match="clusters.*missing or non-finite"): + PooledOLS(cov_type="clustered").fit( + formula="y ~ x + z", + data=data, + cluster=clusters, + ) + + +def test_stage_c_inference_populates_unified_result_and_internal_attributes(): + data = _frame(128033) + model = PooledOLS(cov_type="hc0").fit( + data[["x", "z"]].to_numpy(), + data["y"].to_numpy(), + ) + assert isinstance(model._inference_result, ParameterInferenceResult) + assert_allclose(model._params, model.coef_) + assert_allclose(model._bse, model.bse_) + assert_allclose(model._tvalues, model.tvalues_) + assert_allclose(model._zvalues, model.tvalues_) + assert_allclose(model._pvalues, model.pvalues_) + assert_allclose(model._conf_int, model.conf_int_) + + adjusted = model.adjust_pvalues() + assert adjusted["pvalues_adjusted"].shape == model.pvalues_.shape + combined = model.combine_pvalues() + assert np.isfinite(float(combined["pvalue"])) + + +def test_dk_is_invariant_to_row_permutation_within_and_across_time_groups(): + rng = np.random.default_rng(12804) + time = np.tile(np.arange(7), 8) + X = np.column_stack([np.ones(time.size), rng.normal(size=(time.size, 2))]) + resid = rng.normal(size=time.size) + base = driscoll_kraay_covariance( + X, resid, time, bandwidth=2, kernel="parzen" + ) + order = rng.permutation(time.size) + permuted = driscoll_kraay_covariance( + X[order], resid[order], time[order], bandwidth=2, kernel="parzen" + ) + assert_allclose(permuted, base, rtol=2e-12, atol=2e-13) + + +def test_dk_rejects_mixed_nonorderable_time_labels(): + X = np.column_stack([np.ones(4), np.arange(4.0)]) + resid = np.array([0.1, -0.2, 0.3, -0.1]) + time = np.array([0, "one", 2, "three"], dtype=object) + with pytest.raises(ValueError, match="deterministic"): + driscoll_kraay_covariance(X, resid, time, bandwidth=1) + + +def test_robust_random_effects_hausman_has_explicit_covariance_reason(): + data = _frame(12805) + X = data[["x", "z"]].to_numpy() + y = data["y"].to_numpy() + entity = data["entity"].to_numpy() + fe = PanelOLS(entity_effects=True, cov_type="nonrobust").fit( + X, y, entity_ids=entity + ) + re = RandomEffects(cov_type="hc2").fit(X, y, entity_ids=entity) + result = fe.hausman_test(re) + assert result.applicable is False + assert result.reason is not None + assert "nonrobust RE covariance" in result.reason diff --git a/dev/tests/test_panel_stage_c_backend_contract.py b/dev/tests/test_panel_stage_c_backend_contract.py new file mode 100644 index 000000000..0aabf2768 --- /dev/null +++ b/dev/tests/test_panel_stage_c_backend_contract.py @@ -0,0 +1,29 @@ +"""Stage-C backend contracts that can be enforced without a physical GPU.""" + +from __future__ import annotations + +from types import SimpleNamespace + +import numpy as np +from numpy.testing import assert_allclose + +from statgpu.panel import _utils + + +def test_cupy_scatter_add_never_routes_values_through_host(monkeypatch): + """The CuPy scatter path must remain backend-native even if cupyx is absent.""" + + def _forbid_host_conversion(*args, **kwargs): + raise AssertionError("CuPy scatter_add attempted a host conversion") + + monkeypatch.setattr(_utils, "_to_numpy", _forbid_host_conversion) + fake_cupy = SimpleNamespace( + __name__="cupy", + zeros=np.zeros, + add=np.add, + ) + indices = np.array([0, 1, 0, 2, 1], dtype=np.int64) + values = np.array([1.5, -2.0, 0.5, 4.0, 3.0], dtype=np.float64) + + actual = _utils._scatter_add(fake_cupy, indices, values, n_groups=3) + assert_allclose(actual, np.array([2.0, 1.0, 4.0])) diff --git a/dev/tests/test_panel_stage_c_covariance.py b/dev/tests/test_panel_stage_c_covariance.py new file mode 100644 index 000000000..b41c9f07b --- /dev/null +++ b/dev/tests/test_panel_stage_c_covariance.py @@ -0,0 +1,323 @@ +"""Focused Stage-C covariance correctness and compatibility contracts.""" + +from __future__ import annotations + +import numpy as np +import pytest +from numpy.testing import assert_allclose + +from statgpu.panel import ( + BetweenOLS, + FirstDifferenceOLS, + PanelOLS, + PooledOLS, + RandomEffects, +) +from statgpu.panel._covariance import ( + _dk_kernel_weights, + clustered_covariance, + driscoll_kraay_covariance, + hac_covariance, + normalize_covariance_type, + ols_covariance, + two_way_clustered_covariance, +) + + +def _panel(seed=12600, *, unbalanced=False): + rng = np.random.default_rng(seed) + n_entities, n_times = 10, 7 + 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(rng.normal(scale=0.45, size=n_entities), n_times) + tau = np.tile(np.linspace(-0.2, 0.25, n_times), n_entities) + y = 0.75 * X[:, 0] - 0.35 * X[:, 1] + alpha + 0.3 * tau + y += rng.normal(scale=0.25, size=entity.size) + if unbalanced: + keep = np.ones(entity.size, dtype=bool) + keep[[1, 9, 18, 32, 51]] = False + X, y, entity, time = X[keep], y[keep], entity[keep], time[keep] + return X, y, entity, time + + +def _manual_hc(X, resid, power): + bread = np.linalg.pinv(X.T @ X) + h = np.sum((X @ bread) * X, axis=1) + scale = (1.0 - h) ** (-power) + meat = X.T @ (X * (resid * resid * scale)[:, None]) + return bread @ meat @ bread + + +def _manual_dk(X, resid, time, bandwidth, extra_df=0): + bread = np.linalg.pinv(X.T @ X) + unique = np.unique(time) + scores = X * resid[:, None] + grouped = np.stack([scores[time == value].sum(axis=0) for value in unique]) + meat = grouped.T @ grouped + for lag in range(1, min(bandwidth, len(unique) - 1) + 1): + weight = 1.0 - lag / (bandwidth + 1.0) + gamma = grouped[lag:].T @ grouped[:-lag] + meat += weight * (gamma + gamma.T) + rank = np.linalg.matrix_rank(X) + denom = X.shape[0] - extra_df - rank + return (X.shape[0] / denom) * bread @ meat @ bread + + +def test_covariance_aliases_are_canonical_and_backward_compatible(): + assert normalize_covariance_type("HC1") == "robust" + assert normalize_covariance_type("dk") == "driscoll-kraay" + assert normalize_covariance_type("kernel") == "driscoll-kraay" + assert normalize_covariance_type("robust") == "robust" + + +def test_hc0_hc2_hc3_match_direct_fit_space_sandwich(): + rng = np.random.default_rng(12601) + X = np.column_stack([np.ones(30), rng.normal(size=(30, 2))]) + y = X @ np.array([0.3, 0.8, -0.4]) + rng.normal(scale=0.2, size=30) + beta = np.linalg.lstsq(X, y, rcond=None)[0] + resid = y - X @ beta + + hc0 = ols_covariance(X, resid, cov_type="hc0") + bread = np.linalg.pinv(X.T @ X) + expected0 = bread @ (X.T @ (X * (resid * resid)[:, None])) @ bread + assert_allclose(hc0, expected0, rtol=2e-12, atol=2e-14) + + hc2 = ols_covariance(X, resid, cov_type="hc2") + hc3 = ols_covariance(X, resid, cov_type="hc3") + assert_allclose(hc2, _manual_hc(X, resid, 1), rtol=2e-12, atol=2e-14) + assert_allclose(hc3, _manual_hc(X, resid, 2), rtol=2e-12, atol=2e-14) + + +def test_hc2_hc3_reject_unit_leverage_instead_of_clipping(): + X = np.eye(4) + resid = np.ones(4) + with pytest.raises(ValueError, match="leverage is numerically one"): + ols_covariance(X, resid, cov_type="hc2") + with pytest.raises(ValueError, match="leverage is numerically one"): + ols_covariance(X, resid, cov_type="hc3") + + +def test_one_way_group_debias_is_exact_multiplicative_factor(): + rng = np.random.default_rng(12602) + X = np.column_stack([np.ones(24), rng.normal(size=24)]) + resid = rng.normal(size=24) + cluster = np.repeat(np.arange(6), 4) + raw = clustered_covariance(X, resid, cluster) + corrected = clustered_covariance(X, resid, cluster, group_debias=True) + factor = (6.0 / 5.0) * (23.0 / 24.0) + assert_allclose(corrected, raw * factor, rtol=2e-13, atol=2e-15) + + +def test_two_way_cluster_matches_inclusion_exclusion_with_exact_pairs(): + rng = np.random.default_rng(12603) + X = np.column_stack([np.ones(30), rng.normal(size=30)]) + resid = rng.normal(size=30) + c1 = np.repeat(np.arange(5), 6) + c2 = np.tile(np.arange(6), 5) + pair_codes = np.unique(np.column_stack([c1, c2]), axis=0, return_inverse=True)[1] + expected = ( + clustered_covariance(X, resid, c1) + + clustered_covariance(X, resid, c2) + - clustered_covariance(X, resid, pair_codes) + ) + actual = two_way_clustered_covariance(X, resid, c1, c2) + assert_allclose(actual, expected, rtol=2e-13, atol=2e-15) + + +def test_qs_kernel_uses_all_observed_lags_not_bandwidth_cutoff(): + name, weights = _dk_kernel_weights("qs", bandwidth=2, max_lag=8) + assert name == "qs" + assert weights.shape == (9,) + assert weights[0] == 1.0 + assert np.count_nonzero(weights[1:]) == 8 + assert weights[5] != 0.0 + + _, bartlett = _dk_kernel_weights("bartlett", bandwidth=2, max_lag=8) + assert np.count_nonzero(bartlett[1:]) == 2 + assert np.all(bartlett[3:] == 0.0) + + +def test_driscoll_kraay_bartlett_matches_direct_grouped_score_formula(): + rng = np.random.default_rng(12604) + entity = np.repeat(np.arange(8), 6) + time = np.tile(np.arange(6), 8) + X = np.column_stack([np.ones(entity.size), rng.normal(size=(entity.size, 2))]) + y = X @ np.array([0.2, 0.6, -0.25]) + rng.normal(scale=0.25, size=entity.size) + beta = np.linalg.lstsq(X, y, rcond=None)[0] + resid = y - X @ beta + actual = driscoll_kraay_covariance( + X, resid, time, bandwidth=2, kernel="bartlett", extra_df=0 + ) + expected = _manual_dk(X, resid, time, bandwidth=2) + assert_allclose(actual, expected, rtol=2e-12, atol=2e-14) + + +def test_driscoll_kraay_qs_metadata_records_all_lag_support(): + rng = np.random.default_rng(12605) + time = np.tile(np.arange(9), 5) + X = np.column_stack([np.ones(time.size), rng.normal(size=time.size)]) + resid = rng.normal(size=time.size) + metadata = {} + cov = driscoll_kraay_covariance( + X, + resid, + time, + bandwidth=2, + kernel="quadratic-spectral", + metadata=metadata, + ) + assert np.all(np.isfinite(cov)) + assert metadata["kernel"] == "qs" + assert metadata["bandwidth"] == 2 + assert metadata["max_weighted_lag"] == 8 + assert metadata["all_observed_lags_weighted"] is True + + +def test_legacy_hac_bartlett_formula_is_unchanged(): + rng = np.random.default_rng(12606) + X = np.column_stack([np.ones(25), rng.normal(size=25)]) + resid = rng.normal(size=25) + direct = hac_covariance(X, resid, bandwidth=3, kernel="bartlett") + dispatched = ols_covariance( + X, resid, cov_type="hac", bandwidth=3, kernel="bartlett" + ) + assert_allclose(dispatched, direct, rtol=0, atol=0) + + +def test_pooled_robust_and_hc1_alias_are_identical(): + X, y, entity, time = _panel(seed=12607) + robust = PooledOLS(cov_type="robust").fit(X, y, entity_ids=entity) + hc1 = PooledOLS(cov_type="hc1").fit(X, y, entity_ids=entity) + assert_allclose(hc1.coef_, robust.coef_, rtol=0, atol=0) + assert_allclose(hc1.bse_, robust.bse_, rtol=0, atol=0) + assert_allclose(hc1.pvalues_, robust.pvalues_, rtol=0, atol=0) + assert hc1._cov_type == "robust" + + +@pytest.mark.parametrize("cov_type", ["hc0", "hc2", "hc3"]) +def test_pooled_stage_c_hc_changes_inference_not_coefficients(cov_type): + X, y, entity, time = _panel(seed=12608) + base = PooledOLS().fit(X, y, entity_ids=entity) + model = PooledOLS(cov_type=cov_type).fit(X, y, entity_ids=entity) + assert_allclose(model.coef_, base.coef_, rtol=2e-13, atol=2e-14) + assert np.all(np.isfinite(model.bse_)) + assert model._covariance_metadata["covariance"] == cov_type + + +@pytest.mark.parametrize("cov_type", ["hc0", "hc2", "hc3"]) +def test_panel_stage_c_hc_changes_inference_not_coefficients(cov_type): + X, y, entity, time = _panel(seed=12609, unbalanced=True) + base = PanelOLS(entity_effects=True).fit(X, y, entity_ids=entity) + model = PanelOLS(entity_effects=True, cov_type=cov_type).fit( + X, y, entity_ids=entity + ) + assert_allclose(model.coef_, base.coef_, rtol=2e-12, atol=2e-13) + assert np.all(np.isfinite(model.bse_)) + + +@pytest.mark.parametrize("cov_type", ["hc0", "hc2", "hc3"]) +def test_between_stage_c_hc_changes_inference_not_coefficients(cov_type): + X, y, entity, time = _panel(seed=12610, unbalanced=True) + base = BetweenOLS().fit(X, y, entity_ids=entity) + model = BetweenOLS(cov_type=cov_type).fit(X, y, entity_ids=entity) + assert_allclose(model.coef_, base.coef_, rtol=2e-12, atol=2e-13) + assert np.all(np.isfinite(model.bse_)) + + +@pytest.mark.parametrize("cov_type", ["hc0", "hc2", "hc3"]) +def test_first_difference_stage_c_hc_changes_inference_not_coefficients(cov_type): + X, y, entity, time = _panel(seed=12611) + base = FirstDifferenceOLS().fit(X, y, entity_ids=entity, time_ids=time) + model = FirstDifferenceOLS(cov_type=cov_type).fit( + X, y, entity_ids=entity, time_ids=time + ) + assert_allclose(model.coef_, base.coef_, rtol=2e-12, atol=2e-13) + assert np.all(np.isfinite(model.bse_)) + + +@pytest.mark.parametrize("cov_type", ["robust", "hc0", "hc2", "hc3"]) +def test_random_effects_stage_c_hc_does_not_change_swamy_arora_estimate(cov_type): + X, y, entity, time = _panel(seed=12612, unbalanced=True) + X = np.column_stack([np.ones(len(y)), X]) + base = RandomEffects().fit(X, y, entity_ids=entity) + model = RandomEffects(cov_type=cov_type).fit(X, y, entity_ids=entity) + assert_allclose(model.coef_, base.coef_, rtol=2e-12, atol=2e-13) + assert_allclose( + [model.variance_components_["sigma2_e"], model.variance_components_["sigma2_a"]], + [base.variance_components_["sigma2_e"], base.variance_components_["sigma2_a"]], + rtol=2e-13, + atol=2e-14, + ) + assert np.all(np.isfinite(model.bse_)) + + +def test_pooled_and_random_effects_driscoll_kraay_execute_with_time_metadata(): + X, y, entity, time = _panel(seed=12613, unbalanced=True) + pooled = PooledOLS(cov_type="dk", bandwidth=2).fit( + X, y, entity_ids=entity, time_index=time + ) + re = RandomEffects(cov_type="driscoll-kraay", bandwidth=2).fit( + X, y, entity_ids=entity, time_ids=time + ) + assert pooled._covariance_metadata["covariance"] == "driscoll-kraay" + assert re._covariance_metadata["covariance"] == "driscoll-kraay" + assert pooled._covariance_metadata["n_periods"] == len(np.unique(time)) + assert re._covariance_metadata["n_periods"] == len(np.unique(time)) + assert np.all(np.isfinite(pooled.bse_)) + assert np.all(np.isfinite(re.bse_)) + + +def test_panel_driscoll_kraay_records_standard_effect_rank_extra_df(): + X, y, entity, time = _panel(seed=12614, unbalanced=True) + model = PanelOLS( + entity_effects=True, + time_effects=True, + cov_type="driscoll-kraay", + bandwidth=2, + ).fit(X, y, entity_ids=entity, time_ids=time) + expected = model.fit_statistics_.metadata["diagnostic_df"]["effect_rank"] + assert model._covariance_metadata["extra_df"] == expected + assert np.all(np.isfinite(model.bse_)) + + +def test_cluster_group_debias_is_opt_in_and_coefficients_unchanged(): + X, y, entity, time = _panel(seed=12615) + clusters = np.column_stack([entity, time]) + base = PooledOLS(cov_type="clustered").fit(X, y, cluster=clusters) + corrected = PooledOLS(cov_type="clustered", group_debias=True).fit( + X, y, cluster=clusters + ) + assert_allclose(corrected.coef_, base.coef_, rtol=0, atol=0) + assert corrected._covariance_metadata["group_debias"] is True + assert corrected._covariance_metadata["cluster_dimensions"] == 2 + assert corrected._covariance_metadata["cluster_group_counts"][:2] == [10, 7] + + +def test_group_debias_rejected_for_noncluster_covariance(): + X, y, entity, time = _panel(seed=12616) + with pytest.raises(ValueError, match="requires cov_type='clustered'"): + PooledOLS(cov_type="hc2", group_debias=True).fit(X, y) + with pytest.raises(ValueError, match="requires cov_type='clustered'"): + RandomEffects(cov_type="hc2", group_debias=True).fit( + X, y, entity_ids=entity + ) + + +def test_driscoll_kraay_requires_time_metadata(): + X, y, entity, time = _panel(seed=12617) + with pytest.raises(ValueError, match="time_index is required"): + PooledOLS(cov_type="dk").fit(X, y) + with pytest.raises(ValueError, match="time_ids is required"): + PanelOLS(entity_effects=True, cov_type="dk").fit( + X, y, entity_ids=entity + ) + with pytest.raises(ValueError, match="time_ids is required"): + RandomEffects(cov_type="dk").fit(X, y, entity_ids=entity) + + +def test_between_and_first_difference_explicitly_reject_dk(): + with pytest.raises(ValueError, match="cov_type"): + BetweenOLS(cov_type="dk") + with pytest.raises(ValueError, match="cov_type"): + FirstDifferenceOLS(cov_type="dk") diff --git a/dev/tests/test_panel_stage_c_edge_contracts.py b/dev/tests/test_panel_stage_c_edge_contracts.py new file mode 100644 index 000000000..f61db7652 --- /dev/null +++ b/dev/tests/test_panel_stage_c_edge_contracts.py @@ -0,0 +1,153 @@ +"""Edge contracts for public Panel Stage-C covariance primitives.""" + +from __future__ import annotations + +import numpy as np +import pytest + +from statgpu.panel import PooledOLS, driscoll_kraay_covariance +from statgpu.panel._covariance import clustered_covariance + + +def _fit_space(seed=12950, n_times=6): + rng = np.random.default_rng(seed) + time = np.tile(np.arange(n_times), 5) + X = np.column_stack([np.ones(time.size), rng.normal(size=time.size)]) + resid = rng.normal(size=time.size) + return X, resid, time + + +@pytest.mark.parametrize( + "labels", + [ + np.array([0.0, 1.0, np.nan, 2.0]), + np.array([0.0, 1.0, np.inf, 2.0]), + np.array(["a", "b", None, "c"], dtype=object), + np.array([np.datetime64("2026-01-01"), np.datetime64("NaT")]), + ], +) +def test_group_label_factorization_rejects_missing_or_nonfinite_values(labels): + n = len(labels) + X = np.column_stack([np.ones(n), np.arange(float(n))]) + resid = np.linspace(-0.2, 0.3, n) + with pytest.raises(ValueError, match="must not contain missing or non-finite values"): + clustered_covariance(X, resid, labels) + + +def test_public_driscoll_kraay_rejects_missing_time_labels(): + X, resid, time = _fit_space() + time = time.astype(float) + time[7] = np.nan + with pytest.raises(ValueError, match="must not contain missing or non-finite values"): + driscoll_kraay_covariance(X, resid, time, bandwidth=2) + + +@pytest.mark.parametrize("kernel", ["bartlett", "parzen"]) +def test_truncated_kernels_do_not_silently_cap_oversized_bandwidth(kernel): + X, resid, time = _fit_space(n_times=5) + meta = {} + cov_large = driscoll_kraay_covariance( + X, resid, time, bandwidth=9, kernel=kernel, metadata=meta + ) + cov_capped = driscoll_kraay_covariance( + X, resid, time, bandwidth=4, kernel=kernel + ) + assert meta["bandwidth"] == 9 + assert meta["max_weighted_lag"] == 4 + # The requested bandwidth remains in the Bartlett/Parzen weight formula; + # silently replacing 9 by T-1=4 would make these matrices identical. + assert not np.allclose(cov_large, cov_capped, rtol=1e-12, atol=1e-14) + + +def test_qs_oversized_bandwidth_remains_a_smoothing_scale(): + X, resid, time = _fit_space(n_times=5) + meta = {} + cov = driscoll_kraay_covariance( + X, resid, time, bandwidth=9, kernel="qs", metadata=meta + ) + assert np.all(np.isfinite(cov)) + assert meta["bandwidth"] == 9 + assert meta["all_observed_lags_weighted"] is True + assert meta["max_weighted_lag"] == 4 + + +@pytest.mark.parametrize("value", ["false", 0, 1, None]) +def test_cluster_primitives_reject_nonboolean_group_debias(value): + X = np.column_stack([np.ones(8), np.arange(8.0)]) + resid = np.linspace(-0.2, 0.3, 8) + groups = np.repeat(np.arange(4), 2) + with pytest.raises(ValueError, match="group_debias must be boolean"): + clustered_covariance(X, resid, groups, group_debias=value) + + + +def test_dk_preserves_ordered_categorical_chronology(): + pd = pytest.importorskip("pandas") + rng = np.random.default_rng(12951) + labels = np.tile(np.array(["t1", "t2", "t10"], dtype=object), 9) + numeric = np.tile(np.arange(3), 9) + ordered = pd.Categorical( + labels, + categories=["t1", "t2", "t10"], + ordered=True, + ) + X = np.column_stack([np.ones(labels.size), rng.normal(size=labels.size)]) + resid = rng.normal(size=labels.size) + + actual = driscoll_kraay_covariance( + X, resid, ordered, bandwidth=1, kernel="bartlett" + ) + expected = driscoll_kraay_covariance( + X, resid, numeric, bandwidth=1, kernel="bartlett" + ) + lexical = driscoll_kraay_covariance( + X, resid, np.asarray(ordered, dtype=object), bandwidth=1, kernel="bartlett" + ) + + np.testing.assert_allclose(actual, expected, rtol=2e-13, atol=2e-15) + assert not np.allclose(actual, lexical, rtol=1e-10, atol=1e-12) + + +def test_dk_ordered_categorical_rejects_missing_codes(): + pd = pytest.importorskip("pandas") + labels = pd.Categorical( + ["t1", "t2", None, "t10"], + categories=["t1", "t2", "t10"], + ordered=True, + ) + X = np.column_stack([np.ones(4), np.arange(4.0)]) + resid = np.linspace(-0.2, 0.3, 4) + with pytest.raises(ValueError, match="must not contain missing or non-finite values"): + driscoll_kraay_covariance(X, resid, labels, bandwidth=1) + + +def test_pooled_formula_dk_preserves_ordered_categorical_after_row_alignment(): + pd = pytest.importorskip("pandas") + rng = np.random.default_rng(12952) + labels = np.tile(np.array(["t1", "t2", "t10"], dtype=object), 12) + numeric = np.tile(np.arange(3), 12) + ordered = pd.Categorical( + labels, + categories=["t1", "t2", "t10"], + ordered=True, + ) + x = rng.normal(size=labels.size) + y = 0.4 + 0.7 * x + rng.normal(scale=0.2, size=labels.size) + x_with_gap = x.copy() + x_with_gap[5] = np.nan + data = pd.DataFrame({"y": y, "x": x_with_gap}) + + categorical_fit = PooledOLS(cov_type="dk", bandwidth=1).fit( + formula="y ~ x", data=data, time_index=ordered + ) + numeric_fit = PooledOLS(cov_type="dk", bandwidth=1).fit( + formula="y ~ x", data=data, time_index=numeric + ) + + np.testing.assert_allclose( + categorical_fit.coef_, numeric_fit.coef_, rtol=0.0, atol=0.0 + ) + np.testing.assert_allclose( + categorical_fit.bse_, numeric_fit.bse_, rtol=2e-13, atol=2e-15 + ) + assert categorical_fit._covariance_metadata["n_periods"] == 3 diff --git a/dev/tests/test_panel_stage_c_exports.py b/dev/tests/test_panel_stage_c_exports.py new file mode 100644 index 000000000..3b5cbf7fd --- /dev/null +++ b/dev/tests/test_panel_stage_c_exports.py @@ -0,0 +1,10 @@ +"""Public export contract for Panel Tier-1 Stage C covariance.""" + +from statgpu import driscoll_kraay_covariance as top_level_dk +from statgpu.panel import driscoll_kraay_covariance as panel_dk +from statgpu.panel._covariance import driscoll_kraay_covariance as internal_dk + + +def test_driscoll_kraay_covariance_is_publicly_exported(): + assert top_level_dk is internal_dk + assert panel_dk is internal_dk diff --git a/dev/tests/test_panel_stage_c_external.py b/dev/tests/test_panel_stage_c_external.py new file mode 100644 index 000000000..293af5dc8 --- /dev/null +++ b/dev/tests/test_panel_stage_c_external.py @@ -0,0 +1,239 @@ +"""Pinned external-definition checks for Panel Stage C covariance.""" + +from __future__ import annotations + +import numpy as np +import pytest +from numpy.testing import assert_allclose + +linearmodels = pytest.importorskip("linearmodels") +statsmodels = pytest.importorskip("statsmodels.api") + +from linearmodels.iv.covariance import KERNEL_LOOKUP +from linearmodels.panel.covariance import ClusteredCovariance, DriscollKraay + +from statgpu.panel._covariance import ( + _dk_kernel_weights, + clustered_covariance, + driscoll_kraay_covariance, + ols_covariance, + two_way_clustered_covariance, +) + + +def _regression(seed=12700, *, n_entities=9, n_times=7): + 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 = np.column_stack([np.ones(entity.size), rng.normal(size=(entity.size, 2))]) + beta = np.array([0.25, 0.7, -0.4]) + eps = rng.normal(scale=0.3, size=entity.size) + y = X @ beta + eps + params = np.linalg.lstsq(X, y, rcond=None)[0] + return X, y, params, entity, time + + +def _ill_conditioned_regression(seed=12709): + rng = np.random.default_rng(seed) + n = 50 + x = rng.normal(size=n) + noise = rng.normal(size=n) + X = np.column_stack([np.ones(n), x, x + 1.0e-9 * noise]) + y = X @ np.array([0.4, 0.8, -0.35]) + rng.normal(scale=0.25, size=n) + assert np.linalg.matrix_rank(X) == 3 + assert np.linalg.cond(X) > 1.0e8 + assert np.linalg.cond(X.T @ X) > 1.0e15 + return X, y + + +def _stable_hc_reference(X, resid, cov_type): + X_pinv = np.linalg.pinv(X) + projection_rows = X_pinv.T + leverage = np.sum(X * projection_rows, axis=1) + if cov_type == "hc0": + adjusted = resid + elif cov_type == "hc2": + adjusted = resid / np.sqrt(1.0 - leverage) + elif cov_type == "hc3": + adjusted = resid / (1.0 - leverage) + else: + raise ValueError(cov_type) + influence = projection_rows * adjusted[:, None] + return influence.T @ influence, leverage + + +@pytest.mark.parametrize("cov_type", ["HC2", "HC3"]) +def test_hc2_hc3_fit_space_covariance_matches_statsmodels(cov_type): + X, y, params, entity, time = _regression(seed=12701) + resid = y - X @ params + actual = ols_covariance(X, resid, cov_type=cov_type.lower()) + expected = ( + statsmodels.OLS(y, X) + .fit() + .get_robustcov_results(cov_type=cov_type) + .cov_params() + ) + assert_allclose(actual, expected, rtol=5e-12, atol=5e-14) + + +def test_ill_conditioned_full_rank_hc0_matches_statsmodels(): + X, y = _ill_conditioned_regression() + fit = statsmodels.OLS(y, X).fit() + actual = ols_covariance(X, np.asarray(fit.resid), cov_type="hc0") + expected = fit.get_robustcov_results(cov_type="HC0").cov_params() + assert_allclose(actual, expected, rtol=2e-6, atol=5e-3) + assert np.all(np.isfinite(actual)) + assert np.all(np.diag(actual) >= 0.0) + assert np.max(np.diag(actual)) > 1.0e10 + + +@pytest.mark.parametrize("cov_type", ["hc2", "hc3"]) +def test_ill_conditioned_full_rank_hc2_hc3_use_stable_leverage(cov_type): + X, y = _ill_conditioned_regression() + fit = statsmodels.OLS(y, X).fit() + metadata = {} + actual = ols_covariance( + X, + np.asarray(fit.resid), + cov_type=cov_type, + metadata=metadata, + ) + expected, leverage = _stable_hc_reference( + X, + np.asarray(fit.resid), + cov_type, + ) + assert_allclose(actual, expected, rtol=5e-11, atol=5e-3) + assert leverage.min() >= -1.0e-12 + assert leverage.max() <= 1.0 + 1.0e-12 + assert metadata["leverage_min"] >= -1.0e-12 + assert metadata["leverage_max"] <= 1.0 + 1.0e-12 + assert np.all(np.isfinite(actual)) + assert np.all(np.diag(actual) >= 0.0) + assert np.max(np.diag(actual)) > 1.0e10 + + +def test_qs_extreme_bandwidth_uses_small_argument_limit(): + canonical, weights = _dk_kernel_weights( + "qs", bandwidth=1_000_000_000, max_lag=2 + ) + assert canonical == "qs" + assert_allclose(weights[1:], np.ones(2), rtol=0.0, atol=2e-16) + + +def test_one_way_group_debiased_cluster_matches_linearmodels_primitive(): + X, y, params, entity, time = _regression(seed=12702) + resid = y - X @ params + actual = clustered_covariance( + X, resid, entity, group_debias=True + ) + expected = ClusteredCovariance( + y[:, None], + X, + params[:, None], + entity[:, None], + time[:, None], + debiased=False, + extra_df=0, + clusters=entity, + group_debias=True, + ).cov + assert_allclose(actual, expected, rtol=5e-12, atol=5e-14) + + +def test_two_way_group_debiased_cluster_matches_linearmodels_primitive(): + X, y, params, entity, time = _regression(seed=12703) + resid = y - X @ params + clusters = np.column_stack([entity, time]) + actual = two_way_clustered_covariance( + X, + resid, + entity, + time, + group_debias=True, + ) + expected = ClusteredCovariance( + y[:, None], + X, + params[:, None], + entity[:, None], + time[:, None], + debiased=False, + extra_df=0, + clusters=clusters, + group_debias=True, + ).cov + assert_allclose(actual, expected, rtol=5e-12, atol=5e-14) + + +@pytest.mark.parametrize( + "kernel,lm_kernel", + [ + ("bartlett", "bartlett"), + ("parzen", "parzen"), + ("qs", "qs"), + ], +) +def test_dk_kernel_weights_match_linearmodels(kernel, lm_kernel): + canonical, actual = _dk_kernel_weights(kernel, bandwidth=2, max_lag=8) + reference = np.asarray(KERNEL_LOOKUP[lm_kernel](2.0, 8), dtype=np.float64) + expected = np.zeros_like(actual) + expected[: reference.size] = reference + assert_allclose(actual, expected, rtol=5e-14, atol=5e-15) + if canonical == "qs": + assert reference.size == actual.size + assert np.count_nonzero(actual[1:]) == 8 + else: + assert np.all(actual[reference.size :] == 0.0) + + +@pytest.mark.parametrize("kernel", ["bartlett", "parzen", "qs"]) +def test_driscoll_kraay_full_rank_covariance_matches_linearmodels(kernel): + X, y, params, entity, time = _regression(seed=12704) + resid = y - X @ params + actual = driscoll_kraay_covariance( + X, + resid, + time, + bandwidth=2, + kernel=kernel, + extra_df=0, + ) + expected = DriscollKraay( + y[:, None], + X, + params[:, None], + entity[:, None], + time[:, None], + debiased=True, + extra_df=0, + kernel=kernel, + bandwidth=2.0, + ).cov + assert_allclose(actual, expected, rtol=5e-12, atol=5e-14) + + +def test_driscoll_kraay_extra_df_matches_linearmodels_scale(): + X, y, params, entity, time = _regression(seed=12705) + resid = y - X @ params + extra_df = 5 + actual = driscoll_kraay_covariance( + X, + resid, + time, + bandwidth=2, + kernel="bartlett", + extra_df=extra_df, + ) + expected = DriscollKraay( + y[:, None], + X, + params[:, None], + entity[:, None], + time[:, None], + debiased=True, + extra_df=extra_df, + kernel="bartlett", + bandwidth=2.0, + ).cov + assert_allclose(actual, expected, rtol=5e-12, atol=5e-14) diff --git a/dev/tests/test_panel_stage_c_external_defaults.py b/dev/tests/test_panel_stage_c_external_defaults.py new file mode 100644 index 000000000..aac0a1f03 --- /dev/null +++ b/dev/tests/test_panel_stage_c_external_defaults.py @@ -0,0 +1,142 @@ +"""Additional pinned external defaults for Panel Stage-C covariance.""" + +from __future__ import annotations + +import numpy as np +import pytest +from numpy.testing import assert_allclose + +pytest.importorskip("linearmodels") + +from linearmodels.panel.covariance import DriscollKraay + +from statgpu.panel._covariance import driscoll_kraay_covariance + + +def test_driscoll_kraay_default_bandwidth_matches_linearmodels_7_0(): + rng = np.random.default_rng(12706) + n_entities, n_times = 12, 15 + entity = np.repeat(np.arange(n_entities), n_times) + time = np.tile(np.arange(n_times), n_entities) + X = np.column_stack([np.ones(entity.size), rng.normal(size=(entity.size, 2))]) + beta = np.array([0.2, 0.65, -0.3]) + y = X @ beta + rng.normal(scale=0.25, size=entity.size) + params = np.linalg.lstsq(X, y, rcond=None)[0] + resid = y - X @ params + + actual_meta = {} + actual = driscoll_kraay_covariance( + X, + resid, + time, + bandwidth=None, + kernel="bartlett", + extra_df=0, + metadata=actual_meta, + ) + expected_bandwidth = int(np.floor(4.0 * (n_times / 100.0) ** (2.0 / 9.0))) + expected = DriscollKraay( + y[:, None], + X, + params[:, None], + entity[:, None], + time[:, None], + debiased=True, + extra_df=0, + kernel="bartlett", + bandwidth=None, + ).cov + + assert actual_meta["bandwidth"] == expected_bandwidth + assert_allclose(actual, expected, rtol=5e-12, atol=5e-14) + + +@pytest.mark.parametrize("kernel", ["bartlett", "parzen"]) +def test_driscoll_kraay_oversized_truncated_kernels_are_documented_extension(kernel): + rng = np.random.default_rng(12707) + n_entities, n_times = 10, 5 + entity = np.repeat(np.arange(n_entities), n_times) + time = np.tile(np.arange(n_times), n_entities) + X = np.column_stack([np.ones(entity.size), rng.normal(size=(entity.size, 2))]) + beta = np.array([0.15, 0.55, -0.2]) + y = X @ beta + rng.normal(scale=0.2, size=entity.size) + params = np.linalg.lstsq(X, y, rcond=None)[0] + resid = y - X @ params + bandwidth = 9 + + meta = {} + actual = driscoll_kraay_covariance( + X, resid, time, bandwidth=bandwidth, kernel=kernel, metadata=meta + ) + + # linearmodels 7.0 materializes bw+1 Bartlett/Parzen weights and its + # cov_kernel rejects that vector when it is longer than the T grouped + # scores. Stage C deliberately extends this edge by retaining the requested + # bandwidth in the weight denominator while accumulating only observed lags. + with pytest.raises(ValueError, match="Length of w"): + _ = DriscollKraay( + y[:, None], + X, + params[:, None], + entity[:, None], + time[:, None], + debiased=True, + extra_df=0, + kernel=kernel, + bandwidth=float(bandwidth), + ).cov + + labels = np.unique(time) + grouped = np.stack([(X[time == t] * resid[time == t, None]).sum(axis=0) for t in labels]) + meat = grouped.T @ grouped + for lag in range(1, len(labels)): + z = lag / float(bandwidth + 1) + if kernel == "bartlett": + weight = 1.0 - z + elif z <= 0.5: + weight = 1.0 - 6.0 * z**2 + 6.0 * z**3 + else: + weight = 2.0 * (1.0 - z) ** 3 + gamma = grouped[lag:].T @ grouped[:-lag] + meat = meat + weight * (gamma + gamma.T) + bread = np.linalg.inv(X.T @ X) + scale = len(y) / float(len(y) - X.shape[1]) + expected = scale * (bread @ meat @ bread) + expected = 0.5 * (expected + expected.T) + + assert meta["bandwidth"] == bandwidth + assert meta["max_weighted_lag"] == n_times - 1 + assert_allclose(actual, expected, rtol=5e-12, atol=5e-14) + + +def test_driscoll_kraay_oversized_qs_matches_linearmodels_7_0(): + rng = np.random.default_rng(12708) + n_entities, n_times = 10, 5 + entity = np.repeat(np.arange(n_entities), n_times) + time = np.tile(np.arange(n_times), n_entities) + X = np.column_stack([np.ones(entity.size), rng.normal(size=(entity.size, 2))]) + beta = np.array([0.1, 0.5, -0.25]) + y = X @ beta + rng.normal(scale=0.2, size=entity.size) + params = np.linalg.lstsq(X, y, rcond=None)[0] + resid = y - X @ params + bandwidth = 9 + + meta = {} + actual = driscoll_kraay_covariance( + X, resid, time, bandwidth=bandwidth, kernel="qs", metadata=meta + ) + expected = DriscollKraay( + y[:, None], + X, + params[:, None], + entity[:, None], + time[:, None], + debiased=True, + extra_df=0, + kernel="qs", + bandwidth=float(bandwidth), + ).cov + + assert meta["bandwidth"] == bandwidth + assert meta["all_observed_lags_weighted"] is True + assert_allclose(actual, expected, rtol=5e-12, atol=5e-14) diff --git a/dev/tests/test_panel_stage_c_frontend_source.py b/dev/tests/test_panel_stage_c_frontend_source.py new file mode 100644 index 000000000..2d6d6ae93 --- /dev/null +++ b/dev/tests/test_panel_stage_c_frontend_source.py @@ -0,0 +1,94 @@ +from __future__ import annotations + +import json +from pathlib import Path + +import pytest + +from dev.benchmarks.frontend_data.parsers.panel_stage_c import ( + parse_panel_stage_c_performance, + parse_panel_stage_c_physical_validation, +) + +ROOT = Path(__file__).resolve().parents[2] +CORRECTNESS = ROOT / "results/pr126_p100/panel_stage_c_gpu_validation_aad53587.json" +PERFORMANCE = ROOT / "results/pr126_p100/panel_stage_c_performance_aad53587.json" + + +def test_stage_c_validation_parser_emits_exact_physical_matrix(): + runs, models, warnings = parse_panel_stage_c_physical_validation( + CORRECTNESS, "remote-p100-pr126-20260810" + ) + assert warnings == [] + assert len(runs) == 64 + assert {run["backend"] for run in runs} == {"cupy", "torch"} + assert sum(run["model_id"] == "PanelCovariancePrimitive" for run in runs) == 12 + assert all(run["metrics"]["validation"]["status"] == "pass" for run in runs) + assert all("timing" not in run["metrics"] for run in runs) + assert all("speedup" not in run["metrics"] for run in runs) + assert {model["model_id"] for model in models} == { + "PooledOLS", "PanelOLS", "RandomEffects", "BetweenOLS", + "FirstDifferenceOLS", "PanelCovariancePrimitive", + } + + +def test_stage_c_performance_parser_emits_timing_without_speedup(): + runs, _, warnings = parse_panel_stage_c_performance( + PERFORMANCE, "remote-p100-pr126-20260810" + ) + assert warnings == [] + assert len(runs) == 58 + assert all(run["metrics"]["timing"]["fit_time_ms"] > 0 for run in runs) + assert all("speedup" not in run["metrics"] for run in runs) + base = [run for run in runs if run["parameters"]["scenario"] == "base"] + high_t = [run for run in runs if run["parameters"]["scenario"] == "high_t_qs"] + assert len(base) == 54 + assert len(high_t) == 4 + assert {run["backend"] for run in high_t} == {"cupy", "torch"} + assert {run["parameters"]["n_times"] for run in high_t} == {200} + assert {run["model_id"] for run in high_t} == {"PooledOLS", "PanelOLS"} + assert {run["scale"]["scale_key"] for run in base} == { + "n10000_p2_t20", "n100000_p2_t20", "n100000_p10_t20" + } + assert {run["scale"]["scale_key"] for run in high_t} == {"n10000_p2_t200"} + assert {run["scale"]["label"] for run in high_t} == {"10K×2 · T=200"} + + +def test_stage_c_performance_parser_fails_closed_on_high_t_contract(tmp_path): + data = json.loads(PERFORMANCE.read_text(encoding="utf-8")) + data["high_t_scale"] = "10000x2x20" + broken = tmp_path / "broken_performance.json" + broken.write_text(json.dumps(data), encoding="utf-8") + with pytest.raises(ValueError, match="high-T scale drifted"): + parse_panel_stage_c_performance(broken, "remote-p100-pr126-20260810") + + +def test_stage_c_validation_parser_fails_closed_on_case_identity(tmp_path): + data = json.loads(CORRECTNESS.read_text(encoding="utf-8")) + del data["backends"]["cupy"]["cases"]["pooled_hc0"] + broken = tmp_path / "broken_validation.json" + broken.write_text(json.dumps(data), encoding="utf-8") + with pytest.raises(ValueError, match="case identity drifted"): + parse_panel_stage_c_physical_validation(broken, "remote-p100-pr126-20260810") + + +def test_stage_c_performance_parser_fails_closed_on_base_matrix_drift(tmp_path): + data = json.loads(PERFORMANCE.read_text(encoding="utf-8")) + base_rows = [row for row in data["rows"] if row["scenario"] == "base"] + assert len(base_rows) == 54 + base_rows[0]["case"] = base_rows[1]["case"] + broken = tmp_path / "broken_base_matrix.json" + broken.write_text(json.dumps(data), encoding="utf-8") + with pytest.raises(ValueError, match="base matrix drifted"): + parse_panel_stage_c_performance(broken, "remote-p100-pr126-20260810") + + +def test_stage_c_performance_parser_fails_closed_on_high_t_backend_matrix_drift(tmp_path): + data = json.loads(PERFORMANCE.read_text(encoding="utf-8")) + high_t = [row for row in data["rows"] if row["scenario"] == "high_t_qs"] + assert len(high_t) == 4 + high_t[0]["backend"] = "torch" + broken = tmp_path / "broken_high_t_matrix.json" + broken.write_text(json.dumps(data), encoding="utf-8") + with pytest.raises(ValueError, match="high-T QS matrix drifted"): + parse_panel_stage_c_performance(broken, "remote-p100-pr126-20260810") diff --git a/dev/tests/test_panel_stage_c_inference_guard.py b/dev/tests/test_panel_stage_c_inference_guard.py new file mode 100644 index 000000000..61d9c44cb --- /dev/null +++ b/dev/tests/test_panel_stage_c_inference_guard.py @@ -0,0 +1,48 @@ +"""Regression tests for fail-closed Stage-C inference storage.""" + +from __future__ import annotations + +import numpy as np +import pytest + +from statgpu.panel import _covariance +from statgpu.panel._base import BasePanelModel + + +class _DummyPanelModel(BasePanelModel): + def __init__(self): + super().__init__(device="cpu", n_jobs=None) + self.alpha = 0.05 + + def fit(self, X=None, y=None): + return self + + def predict(self, X): + return np.asarray(X) + + +def test_negative_variance_guard_is_local_to_each_coefficient(monkeypatch): + """A huge variance elsewhere must not mask a substantive negative variance.""" + + def _fake_covariance(*args, **kwargs): + return np.diag([1.0e14, -1.0]) + + monkeypatch.setattr(_covariance, "ols_covariance", _fake_covariance) + model = _DummyPanelModel() + backend = model._get_backend(backend="auto") + + with pytest.raises( + ValueError, + match="materially negative diagonal variance", + ): + model._panel_store_ols_inference( + np.eye(2), + np.zeros(2), + np.ones(2), + scale=1.0, + df_resid=1, + backend=backend, + cov_type="hc0", + allowed=("hc0",), + diag_floor=1.0e-30, + ) diff --git a/dev/tests/test_panel_stage_c_linearmodels_estimators.py b/dev/tests/test_panel_stage_c_linearmodels_estimators.py new file mode 100644 index 000000000..ff852dce1 --- /dev/null +++ b/dev/tests/test_panel_stage_c_linearmodels_estimators.py @@ -0,0 +1,314 @@ +"""Estimator-level Stage-C covariance alignment against pinned references. + +These tests complement the covariance-primitive checks by proving that public +PooledOLS/PanelOLS integrations pass the intended fit space and fixed-effect +rank into Driscoll-Kraay and clustered covariance. RandomEffects is checked on +statgpu's own Swamy-Arora quasi-demeaned fit space so covariance alignment does +not redefine its coefficient/variance-component contract. +""" + +from __future__ import annotations + +import numpy as np +import pandas as pd +import pytest +from numpy.testing import assert_allclose + +pytest.importorskip("linearmodels") +statsmodels = pytest.importorskip("statsmodels.api") + +from linearmodels.panel import PanelOLS as LMPanelOLS +from linearmodels.panel import PooledOLS as LMPooledOLS +from linearmodels.panel.covariance import ( + ClusteredCovariance, + DriscollKraay, + HeteroskedasticCovariance, +) + +from statgpu.panel import BetweenOLS, FirstDifferenceOLS, PanelOLS, PooledOLS, RandomEffects + + +def _panel(seed=12720, *, unbalanced=True): + rng = np.random.default_rng(seed) + n_entities, n_times = 10, 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)) + alpha = np.repeat(rng.normal(scale=0.45, size=n_entities), n_times) + tau = np.tile(np.linspace(-0.2, 0.25, n_times), n_entities) + y = 0.8 * X[:, 0] - 0.35 * X[:, 1] + alpha + 0.3 * tau + y += rng.normal(scale=0.22, size=entity.size) + if unbalanced: + keep = np.ones(entity.size, dtype=bool) + keep[[1, 10, 19, 37, 58, 71]] = 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 _re_fit_space(X, y, entity, model): + """Reconstruct statgpu's Swamy-Arora quasi-demeaned regression space.""" + _, codes = np.unique(entity, return_inverse=True) + counts_by_group = np.bincount(codes).astype(np.float64) + counts = counts_by_group[codes] + + y_sums = np.bincount(codes, weights=y) + y_bar = (y_sums / counts_by_group)[codes] + X_bar = np.empty_like(X, dtype=np.float64) + for j in range(X.shape[1]): + x_sums = np.bincount(codes, weights=X[:, j]) + X_bar[:, j] = (x_sums / counts_by_group)[codes] + + sigma2_e = float(model.variance_components_["sigma2_e"]) + sigma2_a = float(model.variance_components_["sigma2_a"]) + denom = sigma2_e + counts * sigma2_a + theta = np.where( + denom > 0.0, + 1.0 - np.sqrt(sigma2_e / denom), + 0.0, + ) + y_star = y - theta * y_bar + X_star = X - theta[:, None] * X_bar + params = np.asarray(model.coef_, dtype=np.float64).ravel() + resid = y_star - X_star @ params + return X_star, y_star, params, resid + + +def test_pooled_dk_estimator_matches_linearmodels_full_integration(): + X, y, entity, time = _panel(12721) + y_lm, X_lm = _lm_data(X, y, entity, time, constant=True) + lm = LMPooledOLS(y_lm, X_lm).fit( + cov_type="kernel", + kernel="bartlett", + bandwidth=2, + debiased=True, + ) + sg = PooledOLS(cov_type="dk", kernel="bartlett", bandwidth=2).fit( + X, y, time_index=time + ) + + assert_allclose(sg.coef_, lm.params.to_numpy(), rtol=2e-10, atol=2e-11) + assert_allclose(sg._panel_cov_params_raw, lm.cov.to_numpy(), rtol=5e-9, atol=5e-11) + assert_allclose(sg.bse_, lm.std_errors.to_numpy(), rtol=5e-9, atol=5e-11) + assert sg._covariance_metadata["extra_df"] == 0 + + +def test_pooled_group_debiased_cluster_estimator_matches_linearmodels(): + X, y, entity, time = _panel(12722) + y_lm, X_lm = _lm_data(X, y, entity, time, constant=True) + clusters = pd.Series(entity, index=y_lm.index, name="cluster") + lm = LMPooledOLS(y_lm, X_lm).fit( + cov_type="clustered", + clusters=clusters, + debiased=False, + group_debias=True, + ) + sg = PooledOLS(cov_type="clustered", group_debias=True).fit( + X, y, cluster=entity + ) + + assert_allclose(sg.coef_, lm.params.to_numpy(), rtol=2e-10, atol=2e-11) + assert_allclose(sg._panel_cov_params_raw, lm.cov.to_numpy(), rtol=5e-9, atol=5e-11) + assert sg._covariance_metadata["group_debias"] is True + + +def test_one_way_panel_dk_matches_linearmodels_effect_df_integration(): + X, y, entity, time = _panel(12723) + y_lm, X_lm = _lm_data(X, y, entity, time, constant=False) + lm = LMPanelOLS(y_lm, X_lm, entity_effects=True).fit( + cov_type="kernel", + kernel="bartlett", + bandwidth=2, + debiased=True, + auto_df=True, + count_effects=True, + ) + sg = PanelOLS( + entity_effects=True, + cov_type="dk", + kernel="bartlett", + bandwidth=2, + ).fit(X, y, entity_ids=entity, time_ids=time) + + assert_allclose(sg.coef_, lm.params.to_numpy(), rtol=2e-10, atol=2e-11) + assert_allclose(sg._panel_cov_params_raw, lm.cov.to_numpy(), rtol=5e-9, atol=5e-11) + assert_allclose(sg.bse_, lm.std_errors.to_numpy(), rtol=5e-9, atol=5e-11) + effect_rank = sg.fit_statistics_.metadata["diagnostic_df"]["effect_rank"] + assert sg._covariance_metadata["extra_df"] == effect_rank + + +def test_two_way_panel_dk_matches_linearmodels_effect_df_integration(): + X, y, entity, time = _panel(12724) + 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="kernel", + kernel="parzen", + bandwidth=2, + debiased=True, + auto_df=True, + count_effects=True, + ) + sg = PanelOLS( + entity_effects=True, + time_effects=True, + cov_type="dk", + kernel="parzen", + bandwidth=2, + ).fit(X, y, entity_ids=entity, time_ids=time) + + assert_allclose(sg.coef_, lm.params.to_numpy(), rtol=2e-10, atol=2e-11) + assert_allclose(sg._panel_cov_params_raw, lm.cov.to_numpy(), rtol=5e-9, atol=5e-11) + effect_rank = sg.fit_statistics_.metadata["diagnostic_df"]["effect_rank"] + assert sg._covariance_metadata["extra_df"] == effect_rank + + +def test_random_effects_robust_matches_linearmodels_on_statgpu_fit_space(): + X, y, entity, time = _panel(12725) + X = np.column_stack([np.ones(len(y)), X]) + sg = RandomEffects(cov_type="robust").fit(X, y, entity_ids=entity) + X_star, y_star, params, _ = _re_fit_space(X, y, entity, sg) + + expected = HeteroskedasticCovariance( + y_star[:, None], + X_star, + params[:, None], + entity[:, None], + time[:, None], + debiased=True, + extra_df=0, + ).cov + assert_allclose(sg._panel_cov_params_raw, expected, rtol=5e-9, atol=5e-11) + assert sg._covariance_metadata["hc_equivalent"] == "hc1" + + +@pytest.mark.parametrize("cov_type", ["hc2", "hc3"]) +def test_random_effects_hc2_hc3_matches_statsmodels_on_statgpu_fit_space(cov_type): + X, y, entity, _time = _panel(12726) + X = np.column_stack([np.ones(len(y)), X]) + sg = RandomEffects(cov_type=cov_type).fit(X, y, entity_ids=entity) + X_star, y_star, _params, _ = _re_fit_space(X, y, entity, sg) + + expected = ( + statsmodels.OLS(y_star, X_star) + .fit() + .get_robustcov_results(cov_type=cov_type.upper()) + .cov_params() + ) + assert_allclose(sg._panel_cov_params_raw, expected, rtol=5e-9, atol=5e-11) + + +def test_random_effects_two_way_cluster_fails_closed_when_reference_variance_is_negative(): + X, y, entity, time = _panel(12727) + X = np.column_stack([np.ones(len(y)), X]) + clusters = np.column_stack([entity, time]) + + # Reconstruct the same Swamy-Arora fit space from a covariance-invariant + # successful fit, then verify the external two-way cluster definition really + # has a materially negative variance for this deterministic fixture. + base = RandomEffects(cov_type="nonrobust").fit(X, y, entity_ids=entity) + X_star, y_star, params, _ = _re_fit_space(X, y, entity, base) + expected = ClusteredCovariance( + y_star[:, None], + X_star, + params[:, None], + entity[:, None], + time[:, None], + debiased=False, + extra_df=0, + clusters=clusters, + group_debias=True, + ).cov + assert np.min(np.diag(expected)) < -1.0e-12 + + with pytest.raises( + ValueError, + match="materially negative diagonal variance", + ): + RandomEffects(cov_type="clustered", group_debias=True).fit( + X, y, entity_ids=entity, cluster=clusters + ) + + +def test_random_effects_dk_matches_linearmodels_on_statgpu_fit_space(): + X, y, entity, time = _panel(12728) + X = np.column_stack([np.ones(len(y)), X]) + sg = RandomEffects(cov_type="dk", kernel="parzen", bandwidth=2).fit( + X, y, entity_ids=entity, time_ids=time + ) + X_star, y_star, params, _ = _re_fit_space(X, y, entity, sg) + + expected = DriscollKraay( + y_star[:, None], + X_star, + params[:, None], + entity[:, None], + time[:, None], + debiased=True, + extra_df=0, + kernel="parzen", + bandwidth=2.0, + ).cov + assert_allclose(sg._panel_cov_params_raw, expected, rtol=5e-9, atol=5e-11) + assert sg._covariance_metadata["extra_df"] == 0 + + +@pytest.mark.parametrize("cov_type", ["hc0", "hc2", "hc3"]) +def test_between_hc_matches_statsmodels_on_entity_mean_fit_space(cov_type): + X, y, entity, _time = _panel(12729, unbalanced=True) + sg = BetweenOLS(cov_type=cov_type).fit(X, y, entity_ids=entity) + + X_level = np.column_stack([np.ones(len(y)), X]) + groups = np.unique(entity) + X_mean = np.stack([X_level[entity == group].mean(axis=0) for group in groups]) + y_mean = np.asarray([y[entity == group].mean() for group in groups]) + reference = ( + statsmodels.OLS(y_mean, X_mean) + .fit() + .get_robustcov_results(cov_type=cov_type.upper()) + ) + + assert_allclose(sg.coef_, reference.params, rtol=5e-10, atol=5e-12) + assert_allclose( + sg._panel_cov_params_raw, reference.cov_params(), rtol=5e-9, atol=5e-11 + ) + assert_allclose(sg.bse_, reference.bse, rtol=5e-9, atol=5e-11) + + +@pytest.mark.parametrize("cov_type", ["hc0", "hc2", "hc3"]) +def test_first_difference_hc_matches_statsmodels_on_differenced_fit_space(cov_type): + X, y, entity, time = _panel(12730, unbalanced=False) + sg = FirstDifferenceOLS(cov_type=cov_type).fit( + X, y, entity_ids=entity, time_ids=time + ) + + order = np.lexsort((time, entity)) + X_sorted = X[order] + y_sorted = y[order] + entity_sorted = entity[order] + same_entity = entity_sorted[1:] == entity_sorted[:-1] + X_diff = (X_sorted[1:] - X_sorted[:-1])[same_entity] + y_diff = (y_sorted[1:] - y_sorted[:-1])[same_entity] + reference = ( + statsmodels.OLS(y_diff, X_diff) + .fit() + .get_robustcov_results(cov_type=cov_type.upper()) + ) + + assert_allclose(sg.coef_, reference.params, rtol=5e-10, atol=5e-12) + assert_allclose( + sg._panel_cov_params_raw, reference.cov_params(), rtol=5e-9, atol=5e-11 + ) + assert_allclose(sg.bse_, reference.bse, rtol=5e-9, atol=5e-11) diff --git a/dev/tests/test_panel_stage_c_performance_runner_contract.py b/dev/tests/test_panel_stage_c_performance_runner_contract.py new file mode 100644 index 000000000..645845d80 --- /dev/null +++ b/dev/tests/test_panel_stage_c_performance_runner_contract.py @@ -0,0 +1,57 @@ +"""Hosted contract checks for the Stage-C physical performance runner.""" + +from __future__ import annotations + +import importlib.util +from pathlib import Path + +import numpy as np +import pytest + + +def _runner(): + path = Path(__file__).resolve().parents[1] / "benchmarks" / "benchmark_panel_stage_c_covariance.py" + spec = importlib.util.spec_from_file_location("panel_stage_c_perf_runner", path) + module = importlib.util.module_from_spec(spec) + assert spec.loader is not None + spec.loader.exec_module(module) + return module + + +def test_high_t_scenario_is_explicit_and_qs_only(): + mod = _runner() + n, k, n_times = mod._parse_high_t_scale(mod.DEFAULT_HIGH_T_SCALE) + assert (n, k, n_times) == (10000, 2, 200) + assert n_times >= 200 + assert set(mod.HIGH_T_CASES) == {"pooled_dk_qs", "panel_entity_dk_qs"} + + +def test_dataset_honors_requested_time_dimension(): + mod = _runner() + X, y, entity, time, clusters = mod._dataset(1000, 2, 42, n_times=100) + assert X.shape == (1000, 2) + assert y.shape == (1000,) + assert clusters.shape == (1000, 2) + assert len(np.unique(time)) == 100 + assert len(entity) == 1000 + with pytest.raises(ValueError, match="n>=n_times"): + mod._dataset(10, 2, 42, n_times=20) + + +def test_timing_row_schema_records_scenario_and_time_dimension(): + mod = _runner() + row = mod._timing_row( + backend="cupy", + case="pooled_dk_qs", + scenario="high_t_qs", + n=10000, + k=2, + n_times=200, + repeats=3, + samples=[0.3, 0.2, 0.4], + ) + assert row["scenario"] == "high_t_qs" + assert row["n_times"] == 200 + assert row["median_seconds"] == pytest.approx(0.3) + assert row["samples_seconds"] == [0.3, 0.2, 0.4] + assert mod.PERFORMANCE_SCHEMA_VERSION >= 2 diff --git a/dev/tests/test_panel_stage_c_physical_runner_contract.py b/dev/tests/test_panel_stage_c_physical_runner_contract.py new file mode 100644 index 000000000..ea9da9c66 --- /dev/null +++ b/dev/tests/test_panel_stage_c_physical_runner_contract.py @@ -0,0 +1,89 @@ +"""Hosted contract checks for the Stage-C physical GPU validator.""" + +from __future__ import annotations + +import importlib.util +from pathlib import Path + +import numpy as np + + +_RUNNER = Path("dev/benchmarks/validate_panel_stage_c_gpu.py") +_SPEC = importlib.util.spec_from_file_location("panel_stage_c_gpu_runner", _RUNNER) +assert _SPEC is not None and _SPEC.loader is not None +_MOD = importlib.util.module_from_spec(_SPEC) +_SPEC.loader.exec_module(_MOD) + + +def test_stage_c_runner_numpy_reference_matrix_is_complete_and_executable(): + X, y, entity, time, clusters = _MOD._dataset() + cases = _MOD._fit_cases(X, y, entity, time, clusters, "numpy") + required = { + "pooled_hc0", "pooled_hc2", "pooled_hc3", + "pooled_cluster_one_way", "pooled_cluster_two_way_group_debias", + "pooled_dk_bartlett", "pooled_dk_qs", "pooled_legacy_hac", + "panel_entity_hc0", "panel_entity_hc2", "panel_entity_hc3", + "panel_two_way_hc3", "panel_two_way_cluster_group_debias", "panel_two_way_dk", + "random_effects_explicit_constant_robust", + "random_effects_explicit_constant_hc0", + "random_effects_explicit_constant_hc2", + "random_effects_explicit_constant_hc3", + "random_effects_cluster_two_way", "random_effects_dk", + "between_hc0", "between_hc2", "between_hc3", + "first_difference_hc0", "first_difference_hc2", "first_difference_hc3", + } + assert required <= set(cases) + assert len(cases) == len(required) + for name, model in cases.items(): + snap = _MOD._snapshot(model) + assert np.all(np.isfinite(snap["coef"])), name + assert np.all(np.isfinite(snap["bse"])), name + assert np.all(np.isfinite(snap["covariance"])), name + + +def test_stage_c_runner_physically_requires_qs_all_lag_contract(): + X, y, entity, time, clusters = _MOD._dataset() + cases = _MOD._fit_cases(X, y, entity, time, clusters, "numpy") + qs = _MOD._snapshot(cases["pooled_dk_qs"])["covariance_metadata"] + assert qs["kernel"] == "qs" + assert qs["bandwidth"] == 2 + assert qs["n_periods"] == len(np.unique(time)) + assert qs["all_observed_lags_weighted"] is True + assert qs["max_weighted_lag"] == len(np.unique(time)) - 1 + + +def test_stage_c_runner_group_debias_and_panel_dk_metadata_are_auditable(): + X, y, entity, time, clusters = _MOD._dataset() + cases = _MOD._fit_cases(X, y, entity, time, clusters, "numpy") + clustered = _MOD._snapshot( + cases["panel_two_way_cluster_group_debias"] + )["covariance_metadata"] + assert clustered["group_debias"] is True + assert clustered["cluster_dimensions"] == 2 + assert len(clustered["cluster_group_counts"]) == 3 + assert len(clustered["group_debias_factors"]) == 3 + + panel_dk = cases["panel_two_way_dk"] + dk_meta = _MOD._snapshot(panel_dk)["covariance_metadata"] + effect_rank = panel_dk.fit_statistics_.metadata["diagnostic_df"]["effect_rank"] + assert dk_meta["extra_df"] == effect_rank + assert dk_meta["rank_deficient_extension"] is False + + +def test_stage_c_runner_public_primitive_matrix_is_complete(): + X, y, entity, time, clusters = _MOD._dataset() + values = _MOD._public_primitive_cases( + X, y, entity, time, clusters, "numpy" + ) + assert set(values) == { + "cluster_group_debias", + "driscoll_kraay_qs", + "ill_conditioned_hc0", + "ill_conditioned_hc2", + "ill_conditioned_hc3", + "ill_conditioned_dk", + } + for value in values.values(): + arr = np.asarray(value, dtype=np.float64) + assert arr.shape == (3, 3) + assert np.all(np.isfinite(arr)) diff --git a/dev/tests/test_panel_stage_c_r_external.py b/dev/tests/test_panel_stage_c_r_external.py new file mode 100644 index 000000000..7dea78b91 --- /dev/null +++ b/dev/tests/test_panel_stage_c_r_external.py @@ -0,0 +1,141 @@ +"""R plm/sandwich external-alignment gate for Panel Stage C. + +The permanent workflow opts into this test explicitly. Ordinary local/unit +runs skip it so absence of an R installation is not silently treated as +external evidence. +""" + +from __future__ import annotations + +import os +import shutil +import subprocess +from pathlib import Path + +import numpy as np +import pytest +from numpy.testing import assert_allclose + +from statgpu.panel import PanelOLS +from statgpu.panel._covariance import ols_covariance + + +pytestmark = pytest.mark.skipif( + os.environ.get("STATGPU_RUN_R_PANEL_EXTERNAL") != "1", + reason="set STATGPU_RUN_R_PANEL_EXTERNAL=1 in the dedicated R external gate", +) + + +def _dataset(seed=12720): + rng = np.random.default_rng(seed) + n_entities, n_times = 12, 6 + 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(rng.normal(scale=0.45, size=n_entities), n_times) + y = 0.6 + 0.8 * x1 - 0.35 * x2 + alpha + y += rng.normal(scale=0.25, size=entity.size) + return y, x1, x2, entity, time + + +def _write_csv(path: Path, y, x1, x2, entity, time): + matrix = np.column_stack([y, x1, x2, entity, time]) + np.savetxt( + path, + matrix, + delimiter=",", + header="y,x1,x2,entity,time", + comments="", + ) + + +def test_r_plm_and_sandwich_alignment(tmp_path): + rscript = shutil.which("Rscript") + if rscript is None: + pytest.fail("dedicated R external gate requires Rscript") + + y, x1, x2, entity, time = _dataset() + data_path = tmp_path / "panel.csv" + _write_csv(data_path, y, x1, x2, entity, time) + + script_path = tmp_path / "reference.R" + script_path.write_text( + r''' +args <- commandArgs(trailingOnly=TRUE) +d <- read.csv(args[1]) +prefix <- args[2] + +fit_lm <- lm(y ~ x1 + x2, data=d) +for (kind in c("HC0", "HC2", "HC3")) { + value <- sandwich::vcovHC(fit_lm, type=kind) + write.table( + value, + file=paste0(prefix, "_", tolower(kind), ".csv"), + sep=",", + row.names=FALSE, + col.names=FALSE + ) +} + +fit_fe <- plm::plm( + y ~ x1 + x2, + data=d, + index=c("entity", "time"), + model="within", + effect="individual" +) +write.table( + matrix(stats::coef(fit_fe), nrow=1), + file=paste0(prefix, "_plm_fe_coef.csv"), + sep=",", + row.names=FALSE, + col.names=FALSE +) +writeLines( + c( + paste0("R=", R.version.string), + paste0("plm=", as.character(utils::packageVersion("plm"))), + paste0("sandwich=", as.character(utils::packageVersion("sandwich"))) + ), + con=paste0(prefix, "_versions.txt") +) +'''.strip() + + "\n", + encoding="utf-8", + ) + + prefix = tmp_path / "r_reference" + subprocess.run( + [rscript, str(script_path), str(data_path), str(prefix)], + check=True, + text=True, + ) + + X = np.column_stack([np.ones(len(y)), x1, x2]) + params = np.linalg.lstsq(X, y, rcond=None)[0] + resid = y - X @ params + for kind in ("hc0", "hc2", "hc3"): + actual = ols_covariance(X, resid, cov_type=kind) + expected = np.loadtxt( + f"{prefix}_{kind}.csv", + delimiter=",", + ndmin=2, + ) + assert_allclose(actual, expected, rtol=5e-9, atol=5e-11) + + fe = PanelOLS(entity_effects=True, cov_type="nonrobust").fit( + np.column_stack([x1, x2]), + y, + entity_ids=entity, + ) + expected_fe = np.loadtxt( + f"{prefix}_plm_fe_coef.csv", + delimiter=",", + ndmin=1, + ).ravel() + assert_allclose(fe.coef_, expected_fe, rtol=5e-10, atol=5e-11) + + versions = Path(f"{prefix}_versions.txt").read_text(encoding="utf-8") + assert "plm=" in versions + assert "sandwich=" in versions diff --git a/dev/tests/test_panel_stage_c_set_params.py b/dev/tests/test_panel_stage_c_set_params.py new file mode 100644 index 000000000..36cc4b9dd --- /dev/null +++ b/dev/tests/test_panel_stage_c_set_params.py @@ -0,0 +1,22 @@ +"""Stage-C covariance alias behavior under sklearn-style set_params.""" + +from statgpu.panel import PanelOLS, PooledOLS, RandomEffects + + +def _assert_alias_refresh(model, raw, canonical): + returned = model.set_params(cov_type=raw) + assert returned is model + assert model.cov_type == raw + assert model._cov_type == canonical + assert model.get_params()["cov_type"] == raw + + +def test_hc1_set_params_preserves_raw_value_and_refreshes_runtime_alias(): + for model in (PooledOLS(), PanelOLS(entity_effects=True), RandomEffects()): + _assert_alias_refresh(model, "hc1", "robust") + + +def test_driscoll_kraay_aliases_refresh_runtime_dispatch_after_set_params(): + for raw in ("dk", "kernel", "driscoll-kraay"): + for model in (PooledOLS(), PanelOLS(entity_effects=True), RandomEffects()): + _assert_alias_refresh(model, raw, "driscoll-kraay") diff --git a/dev/tests/test_panel_stage_c_torch_cpu.py b/dev/tests/test_panel_stage_c_torch_cpu.py new file mode 100644 index 000000000..a4f9f710a --- /dev/null +++ b/dev/tests/test_panel_stage_c_torch_cpu.py @@ -0,0 +1,209 @@ +"""Maintained Torch-CPU parity for Panel Tier-1 Stage C covariance.""" + +from __future__ import annotations + +import numpy as np +import pytest +from numpy.testing import assert_allclose + +from statgpu.panel import BetweenOLS, FirstDifferenceOLS, PanelOLS, PooledOLS, RandomEffects +from statgpu.panel._covariance import driscoll_kraay_covariance, ols_covariance, two_way_clustered_covariance + + +torch = pytest.importorskip("torch") + + +def _panel(seed=12900, *, unbalanced=True): + rng = np.random.default_rng(seed) + n_entities, n_times = 8, 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(rng.normal(scale=0.35, size=n_entities), n_times) + y = 0.75 * X[:, 0] - 0.3 * X[:, 1] + alpha + rng.normal(scale=0.2, size=entity.size) + if unbalanced: + keep = np.ones(entity.size, dtype=bool) + keep[[2, 11, 25, 40]] = False + X, y, entity, time = X[keep], y[keep], entity[keep], time[keep] + 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_inference(actual, expected, *, rtol=2e-8, atol=2e-10): + assert_allclose(actual.coef_, expected.coef_, rtol=rtol, atol=atol) + assert_allclose(actual.bse_, expected.bse_, rtol=rtol, atol=atol) + assert_allclose(actual.tvalues_, expected.tvalues_, rtol=rtol, atol=atol) + assert_allclose(actual.pvalues_, expected.pvalues_, rtol=rtol, atol=atol) + assert_allclose(actual.conf_int_, expected.conf_int_, rtol=rtol, atol=atol) + assert_allclose(actual._panel_cov_params_raw, expected._panel_cov_params_raw, rtol=rtol, atol=atol) + + +@pytest.mark.parametrize("cov_type", ["hc0", "hc2", "hc3"]) +def test_stage_c_hc_primitives_torch_cpu_match_numpy(cov_type): + rng = np.random.default_rng(12901) + X = np.column_stack([np.ones(40), rng.normal(size=(40, 2))]) + resid = rng.normal(size=40) + X_t = torch.as_tensor(X, dtype=torch.float64) + resid_t = torch.as_tensor(resid, dtype=torch.float64) + expected = ols_covariance(X, resid, cov_type=cov_type, xp=np) + actual = ols_covariance(X_t, resid_t, cov_type=cov_type) + assert torch.is_tensor(actual) + assert_allclose(actual.detach().cpu().numpy(), expected, rtol=2e-10, atol=2e-12) + + +@pytest.mark.parametrize("cov_type", ["hc0", "hc2", "hc3"]) +def test_stage_c_ill_conditioned_hc_torch_cpu_matches_numpy(cov_type): + rng = np.random.default_rng(129011) + n = 50 + x = rng.normal(size=n) + X = np.column_stack( + [np.ones(n), x, x + 1.0e-9 * rng.normal(size=n)] + ) + y = X @ np.array([0.2, 0.7, -0.4]) + rng.normal(scale=0.2, size=n) + params = np.linalg.lstsq(X, y, rcond=None)[0] + resid = y - X @ params + assert np.linalg.matrix_rank(X) == 3 + assert np.linalg.cond(X) > 1.0e8 + + expected = ols_covariance(X, resid, cov_type=cov_type, xp=np) + actual = ols_covariance( + torch.as_tensor(X, dtype=torch.float64), + torch.as_tensor(resid, dtype=torch.float64), + cov_type=cov_type, + ) + assert torch.is_tensor(actual) + assert_allclose( + actual.detach().cpu().numpy(), + expected, + rtol=2e-5, + atol=1e-2, + ) + assert np.all(np.diag(actual.detach().cpu().numpy()) >= 0.0) + + +def test_stage_c_two_way_cluster_torch_cpu_matches_numpy_with_group_debias(): + rng = np.random.default_rng(12902) + X = np.column_stack([np.ones(48), rng.normal(size=(48, 2))]) + resid = rng.normal(size=48) + c1 = np.repeat(np.arange(8), 6) + c2 = np.tile(np.arange(6), 8) + expected = two_way_clustered_covariance( + X, resid, c1, c2, xp=np, group_debias=True + ) + actual = two_way_clustered_covariance( + torch.as_tensor(X, dtype=torch.float64), + torch.as_tensor(resid, dtype=torch.float64), + c1, + c2, + group_debias=True, + ) + assert torch.is_tensor(actual) + assert_allclose(actual.detach().cpu().numpy(), expected, rtol=2e-10, atol=2e-12) + + +@pytest.mark.parametrize("kernel", ["bartlett", "parzen", "qs"]) +def test_stage_c_dk_torch_cpu_matches_numpy(kernel): + rng = np.random.default_rng(12903) + time = np.tile(np.arange(8), 7) + X = np.column_stack([np.ones(time.size), rng.normal(size=(time.size, 2))]) + resid = rng.normal(size=time.size) + expected = driscoll_kraay_covariance( + X, resid, time, bandwidth=2, kernel=kernel, extra_df=3, xp=np + ) + actual = driscoll_kraay_covariance( + torch.as_tensor(X, dtype=torch.float64), + torch.as_tensor(resid, dtype=torch.float64), + time, + bandwidth=2, + kernel=kernel, + extra_df=3, + ) + assert torch.is_tensor(actual) + assert_allclose(actual.detach().cpu().numpy(), expected, rtol=2e-10, atol=2e-12) + + +@pytest.mark.parametrize("cov_type", ["hc0", "hc2", "hc3"]) +def test_stage_c_pooled_torch_cpu_hc_matches_numpy(cov_type): + X, y, entity, time = _panel(12904) + X_t, y_t, entity_t, _ = _torch_arrays(X, y, entity, time) + expected = PooledOLS(cov_type=cov_type).fit(X, y, entity_ids=entity) + actual = PooledOLS(cov_type=cov_type).fit(X_t, y_t, entity_ids=entity_t) + _assert_inference(actual, expected) + + +@pytest.mark.parametrize("cov_type", ["hc0", "hc2", "hc3"]) +def test_stage_c_panel_fe_torch_cpu_hc_matches_numpy(cov_type): + X, y, entity, time = _panel(12905) + X_t, y_t, entity_t, _ = _torch_arrays(X, y, entity, time) + expected = PanelOLS(entity_effects=True, cov_type=cov_type).fit(X, y, entity_ids=entity) + actual = PanelOLS(entity_effects=True, cov_type=cov_type).fit(X_t, y_t, entity_ids=entity_t) + _assert_inference(actual, expected) + + +def test_stage_c_panel_dk_torch_cpu_matches_numpy_and_effect_rank_metadata(): + X, y, entity, time = _panel(12906) + X_t, y_t, entity_t, time_t = _torch_arrays(X, y, entity, time) + expected = PanelOLS(entity_effects=True, cov_type="dk", bandwidth=2).fit( + X, y, entity_ids=entity, time_ids=time + ) + actual = PanelOLS(entity_effects=True, cov_type="dk", bandwidth=2).fit( + X_t, y_t, entity_ids=entity_t, time_ids=time_t + ) + _assert_inference(actual, expected) + assert actual._covariance_metadata["extra_df"] == expected._covariance_metadata["extra_df"] + assert actual._covariance_metadata["design_rank"] == expected._covariance_metadata["design_rank"] + + +@pytest.mark.parametrize("cov_type", ["robust", "hc0", "hc2", "hc3"]) +def test_stage_c_random_effects_torch_cpu_covariance_matches_numpy(cov_type): + X, y, entity, time = _panel(12907) + X = np.column_stack([np.ones(len(y)), X]) + X_t, y_t, entity_t, _ = _torch_arrays(X, y, entity, time) + expected = RandomEffects(cov_type=cov_type).fit(X, y, entity_ids=entity) + actual = RandomEffects(cov_type=cov_type).fit(X_t, y_t, entity_ids=entity_t) + _assert_inference(actual, expected, rtol=5e-8, atol=5e-10) + assert_allclose( + [actual.variance_components_["sigma2_e"], actual.variance_components_["sigma2_a"]], + [expected.variance_components_["sigma2_e"], expected.variance_components_["sigma2_a"]], + rtol=2e-10, + atol=2e-12, + ) + + +def test_stage_c_random_effects_dk_torch_cpu_matches_numpy(): + X, y, entity, time = _panel(12908) + X_t, y_t, entity_t, time_t = _torch_arrays(X, y, entity, time) + expected = RandomEffects(cov_type="dk", bandwidth=2, kernel="qs").fit( + X, y, entity_ids=entity, time_ids=time + ) + actual = RandomEffects(cov_type="dk", bandwidth=2, kernel="qs").fit( + X_t, y_t, entity_ids=entity_t, time_ids=time_t + ) + _assert_inference(actual, expected, rtol=5e-8, atol=5e-10) + assert actual._covariance_metadata["all_observed_lags_weighted"] is True + + +@pytest.mark.parametrize("estimator", [BetweenOLS, FirstDifferenceOLS]) +@pytest.mark.parametrize("cov_type", ["hc0", "hc2", "hc3"]) +def test_stage_c_between_and_fd_torch_cpu_hc_match_numpy(estimator, cov_type): + X, y, entity, time = _panel(12909, unbalanced=False) + X_t, y_t, entity_t, time_t = _torch_arrays(X, y, entity, time) + if estimator is BetweenOLS: + expected = estimator(cov_type=cov_type).fit(X, y, entity_ids=entity) + actual = estimator(cov_type=cov_type).fit(X_t, y_t, entity_ids=entity_t) + else: + expected = estimator(cov_type=cov_type).fit( + X, y, entity_ids=entity, time_ids=time + ) + actual = estimator(cov_type=cov_type).fit( + X_t, y_t, entity_ids=entity_t, time_ids=time_t + ) + _assert_inference(actual, expected, rtol=5e-8, atol=5e-10) diff --git a/docs/assets/benchmarks/data/benchmark_data.json b/docs/assets/benchmarks/data/benchmark_data.json index b7b025ba4..d725b3ae7 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": "b425b95947fcb5ee7dcd4e6e10f1b108cfe82b804f5d46428e63c1fb5ca35b1d" + "generation_id": "3fd0701c8d8672eecd804b953ebbdd87f8fa9004d7953be496305ddb6164d3a2" }, "environments": [ { @@ -33,6 +33,12 @@ "label": "Tesla P100 PR #122 Panel Stage B validation — 2026-08-09", "gpu": "Tesla P100-SXM2-16GB", "cpu": "x86_64" + }, + { + "env_id": "remote-p100-pr126-20260810", + "label": "Tesla P100 PR #126 Panel Stage C — 2026-08-10", + "gpu": "Tesla P100-SXM2-16GB", + "cpu": "x86_64" } ], "categories": [ @@ -326,6 +332,15 @@ "supports_penalty": false, "supports_inference": false }, + { + "model_id": "PanelCovariancePrimitive", + "primary_category_id": "panel", + "category_ids": [ + "panel" + ], + "supports_penalty": false, + "supports_inference": true + }, { "model_id": "PanelOLS", "primary_category_id": "panel", @@ -609,6 +624,16 @@ "label": "Panel Stage B physical validation — PR #122 — 2026-08-09", "env_id": "remote-p100-pr122-20260809" }, + { + "comparison_id": "panel-stage-c-pr126-performance-20260810", + "label": "Panel Stage C synchronized performance — PR #126 — 2026-08-10", + "env_id": "remote-p100-pr126-20260810" + }, + { + "comparison_id": "panel-stage-c-pr126-validation-20260810", + "label": "Panel Stage C physical validation — PR #126 — 2026-08-10", + "env_id": "remote-p100-pr126-20260810" + }, { "comparison_id": "penalized-glm-perf-20260622", "label": "Penalized GLM performance — 2026-06-22", @@ -94516,6 +94541,9126 @@ } }, "comparison_id": "panel-stage-b-pr122-20260809" + }, + { + "run_id": "ffa7a2b8ababa030", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "BetweenOLS", + "case_id": "case-602e339be5cd2fa9", + "method_config_id": "method-a09810be8b1ca601", + "variant": "between-hc0", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 3, + "design_columns": 3 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "45afdd869f017422", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "BetweenOLS", + "case_id": "case-69e808d2847ce85d", + "method_config_id": "method-8e0ebf13ace989a2", + "variant": "between-hc2", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.12370974688631295, + "leverage_max": 0.49672782581248387 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "c01ebda399aa0b38", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "BetweenOLS", + "case_id": "case-85cf52cac7d2be79", + "method_config_id": "method-d06f1dd1c3ce3c8a", + "variant": "between-hc3", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.12370974688631295, + "leverage_max": 0.49672782581248387 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "be3ecd88a983f9f8", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "FirstDifferenceOLS", + "case_id": "case-4fdd41d8d1e161ac", + "method_config_id": "method-2f342d8f6ae7ffba", + "variant": "first-difference-hc0", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 2, + "design_columns": 2 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "f1ae74a654ce3239", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "FirstDifferenceOLS", + "case_id": "case-1f138c6d57030c56", + "method_config_id": "method-a32ce6449e2fb8e2", + "variant": "first-difference-hc2", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0006345976206143431, + "leverage_max": 0.20961579624221383 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "c944e7c061446f25", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "FirstDifferenceOLS", + "case_id": "case-eb5e9029d2c5924a", + "method_config_id": "method-afe40611056711c9", + "variant": "first-difference-hc3", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0006345976206143431, + "leverage_max": 0.20961579624221383 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "4e80600d60337aca", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-a11ab9403e16ad92", + "method_config_id": "method-f013c673f09a3863", + "variant": "panel-entity-hc0", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 2, + "design_columns": 2 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "f0cd82270e1c112a", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-1dc8bafefab7ca3d", + "method_config_id": "method-b1cc7e744ee0add7", + "variant": "panel-entity-hc2", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0005744684754546323, + "leverage_max": 0.19529948562793312 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "07ac3fc120801c13", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-f7a19757b7251512", + "method_config_id": "method-7c0a73ca0adc7e40", + "variant": "panel-entity-hc3", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0005744684754546323, + "leverage_max": 0.19529948562793312 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "7418362814172183", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-b5c207c9f8fba578", + "method_config_id": "method-c2cf1012d9478da0", + "variant": "panel-two-way-cluster-group-debias", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 2, + "cluster_group_counts": [ + 10, + 8, + 74 + ], + "group_debias": true, + "group_debias_factors": [ + 1.0960960960960962, + 1.1274131274131274, + 1.0 + ] + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "da0cd0ed92760b3f", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-851139e4ad332095", + "method_config_id": "method-a9001b3fe1061be6", + "variant": "panel-two-way-dk", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "bartlett", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 2, + "all_observed_lags_weighted": false, + "extra_df": 17, + "design_rank": 2, + "design_columns": 2, + "rank_deficient_extension": false, + "df_scale": 1.3454545454545455 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "5e8264632f4940ca", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-e2e124c7ebf4878f", + "method_config_id": "method-8ae1a2e2c28c7bac", + "variant": "panel-two-way-hc3", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0004688530808460156, + "leverage_max": 0.15430313435907284 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "df413c95394908c1", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-0db195a58cc039a1", + "method_config_id": "method-6c71aa40b6ebf75b", + "variant": "pooled-cluster-one-way", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 1, + "cluster_group_counts": [ + 10 + ], + "group_debias": false, + "group_debias_factors": [ + 1.0 + ] + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "78d24d3de926a2b0", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-701bd2295fa58132", + "method_config_id": "method-4a7e6b46a3f858f1", + "variant": "pooled-cluster-two-way-group-debias", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 2, + "cluster_group_counts": [ + 10, + 8, + 74 + ], + "group_debias": true, + "group_debias_factors": [ + 1.0960960960960962, + 1.1274131274131274, + 1.0 + ] + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "1de2cfe03146f43e", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-51336b81abca25e9", + "method_config_id": "method-f15484291b75ee66", + "variant": "pooled-dk-bartlett", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "bartlett", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 2, + "all_observed_lags_weighted": false, + "extra_df": 0, + "design_rank": 3, + "design_columns": 3, + "rank_deficient_extension": false, + "df_scale": 1.0422535211267605 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "07dab7b28df4cdad", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-169288239784647b", + "method_config_id": "method-033b6b6eedcd5542", + "variant": "pooled-dk-qs", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "qs", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 7, + "all_observed_lags_weighted": true, + "extra_df": 0, + "design_rank": 3, + "design_columns": 3, + "rank_deficient_extension": false, + "df_scale": 1.0422535211267605 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "5242322364ff48ba", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-a0098cb9e0ec5789", + "method_config_id": "method-92cf71749956c3e0", + "variant": "pooled-hc0", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 3, + "design_columns": 3 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "d11871839cb7d5dc", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-a4418dfce7964fe2", + "method_config_id": "method-2f6ff2531b0a6ff2", + "variant": "pooled-hc2", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.014035716007961326, + "leverage_max": 0.23145706236692953 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "52a98cc742927c5f", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-e8309fa1968918a3", + "method_config_id": "method-55ee08dcdc174db4", + "variant": "pooled-hc3", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.014035716007961326, + "leverage_max": 0.23145706236692953 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "c890d4732d3d7d98", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-2589dbc750e59c4e", + "method_config_id": "method-10962eabf3c4e7e5", + "variant": "pooled-legacy-hac", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hac", + "kernel": "bartlett", + "bandwidth": 2, + "row_order_hac": true + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "510bc1bf73977f5c", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-4396be726373163f", + "method_config_id": "method-d0fe2c5321adee4b", + "variant": "random-effects-cluster-two-way", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 2, + "cluster_group_counts": [ + 10, + 8, + 74 + ], + "group_debias": true, + "group_debias_factors": [ + 1.0960960960960962, + 1.1274131274131274, + 1.0 + ] + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "38644871822230fd", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-0932beff1128acfc", + "method_config_id": "method-3c277698526e33ed", + "variant": "random-effects-dk", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "parzen", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 2, + "all_observed_lags_weighted": false, + "extra_df": 0, + "design_rank": 3, + "design_columns": 3, + "rank_deficient_extension": false, + "df_scale": 1.0422535211267605 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "d1481eafa864d1cf", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-fb86972c1f229ddc", + "method_config_id": "method-bc1f5572ac47be2d", + "variant": "random-effects-explicit-constant-hc0", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 3, + "design_columns": 3 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "aea44dbf69033fbe", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-3b6202a899b202c5", + "method_config_id": "method-46a1efed634b9b1f", + "variant": "random-effects-explicit-constant-hc2", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.013773465636365004, + "leverage_max": 0.23398280044939512 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "2698547113d08184", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-0ad05ccdc588c746", + "method_config_id": "method-d1a58746479cc13a", + "variant": "random-effects-explicit-constant-hc3", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.013773465636365004, + "leverage_max": 0.23398280044939512 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "7a9e29b07d04373f", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-db82aa7c776f16f8", + "method_config_id": "method-fc7155cf722559da", + "variant": "random-effects-explicit-constant-robust", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "robust", + "hc_equivalent": "hc1", + "hc1_correction": 1.0422535211267605 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "2d2650a27a735fb5", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelCovariancePrimitive", + "case_id": "case-d861c0bd35587898", + "method_config_id": "method-39dcc17d65e965a1", + "variant": "public-cluster-group-debias", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "public_primitive_physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy" + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "primitive_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "0d9188a5004a4d80", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelCovariancePrimitive", + "case_id": "case-da574a2931912ff2", + "method_config_id": "method-c1dd4f1273777fd3", + "variant": "public-driscoll-kraay-qs", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "public_primitive_physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy" + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "primitive_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "e6dda7f03d0e3dd3", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelCovariancePrimitive", + "case_id": "case-d88f200f76d48e35", + "method_config_id": "method-337a25a54644be63", + "variant": "public-ill-conditioned-dk", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "public_primitive_physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy" + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "primitive_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "b24fb1248903a00f", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelCovariancePrimitive", + "case_id": "case-3ae6fa564570f286", + "method_config_id": "method-44c3dcff21d4b8c4", + "variant": "public-ill-conditioned-hc0", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "public_primitive_physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy" + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "primitive_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "9dcdc5586f15571b", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelCovariancePrimitive", + "case_id": "case-ed533f11c321fa36", + "method_config_id": "method-51303a8fd255c778", + "variant": "public-ill-conditioned-hc2", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "public_primitive_physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy" + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "primitive_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "6f292dd8326640ac", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelCovariancePrimitive", + "case_id": "case-adef450c1b1b2a5c", + "method_config_id": "method-ba1967a3dab3096e", + "variant": "public-ill-conditioned-hc3", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "public_primitive_physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy" + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "primitive_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "17a8c5a4435655b8", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "BetweenOLS", + "case_id": "case-602e339be5cd2fa9", + "method_config_id": "method-a09810be8b1ca601", + "variant": "between-hc0", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 3, + "design_columns": 3 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "3e3610b48d64aaa0", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "BetweenOLS", + "case_id": "case-69e808d2847ce85d", + "method_config_id": "method-8e0ebf13ace989a2", + "variant": "between-hc2", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.12370974688631298, + "leverage_max": 0.49672782581248354 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "751af8349183b4fb", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "BetweenOLS", + "case_id": "case-85cf52cac7d2be79", + "method_config_id": "method-d06f1dd1c3ce3c8a", + "variant": "between-hc3", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.12370974688631298, + "leverage_max": 0.49672782581248354 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "319d1c0aa995c1b8", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "FirstDifferenceOLS", + "case_id": "case-4fdd41d8d1e161ac", + "method_config_id": "method-2f342d8f6ae7ffba", + "variant": "first-difference-hc0", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 2, + "design_columns": 2 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "0bf7c785f74bd217", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "FirstDifferenceOLS", + "case_id": "case-1f138c6d57030c56", + "method_config_id": "method-a32ce6449e2fb8e2", + "variant": "first-difference-hc2", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0006345976206143431, + "leverage_max": 0.20961579624221385 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "b51746170e4e35b3", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "FirstDifferenceOLS", + "case_id": "case-eb5e9029d2c5924a", + "method_config_id": "method-afe40611056711c9", + "variant": "first-difference-hc3", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0006345976206143431, + "leverage_max": 0.20961579624221385 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "bda980ba519d4393", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-a11ab9403e16ad92", + "method_config_id": "method-f013c673f09a3863", + "variant": "panel-entity-hc0", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 2, + "design_columns": 2 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "b49489e9fc0e99df", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-1dc8bafefab7ca3d", + "method_config_id": "method-b1cc7e744ee0add7", + "variant": "panel-entity-hc2", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0005744684754546322, + "leverage_max": 0.19529948562793314 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "d5dd6336c08e5112", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-f7a19757b7251512", + "method_config_id": "method-7c0a73ca0adc7e40", + "variant": "panel-entity-hc3", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0005744684754546322, + "leverage_max": 0.19529948562793314 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "e14c2093aba389c8", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-b5c207c9f8fba578", + "method_config_id": "method-c2cf1012d9478da0", + "variant": "panel-two-way-cluster-group-debias", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 2, + "cluster_group_counts": [ + 10, + 8, + 74 + ], + "group_debias": true, + "group_debias_factors": [ + 1.0960960960960962, + 1.1274131274131274, + 1.0 + ] + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "2b654ec0ebddb497", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-851139e4ad332095", + "method_config_id": "method-a9001b3fe1061be6", + "variant": "panel-two-way-dk", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "bartlett", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 2, + "all_observed_lags_weighted": false, + "extra_df": 17, + "design_rank": 2, + "design_columns": 2, + "rank_deficient_extension": false, + "df_scale": 1.3454545454545455 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "5424c4bdc91deb28", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-e2e124c7ebf4878f", + "method_config_id": "method-8ae1a2e2c28c7bac", + "variant": "panel-two-way-hc3", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.000468853080846015, + "leverage_max": 0.15430313435907278 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "c5d42b360c9f5c62", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-0db195a58cc039a1", + "method_config_id": "method-6c71aa40b6ebf75b", + "variant": "pooled-cluster-one-way", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 1, + "cluster_group_counts": [ + 10 + ], + "group_debias": false, + "group_debias_factors": [ + 1.0 + ] + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "0b42ff8900380638", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-701bd2295fa58132", + "method_config_id": "method-4a7e6b46a3f858f1", + "variant": "pooled-cluster-two-way-group-debias", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 2, + "cluster_group_counts": [ + 10, + 8, + 74 + ], + "group_debias": true, + "group_debias_factors": [ + 1.0960960960960962, + 1.1274131274131274, + 1.0 + ] + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "e3715b101715bee2", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-51336b81abca25e9", + "method_config_id": "method-f15484291b75ee66", + "variant": "pooled-dk-bartlett", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "bartlett", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 2, + "all_observed_lags_weighted": false, + "extra_df": 0, + "design_rank": 3, + "design_columns": 3, + "rank_deficient_extension": false, + "df_scale": 1.0422535211267605 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "e35492d064d0d20e", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-169288239784647b", + "method_config_id": "method-033b6b6eedcd5542", + "variant": "pooled-dk-qs", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "qs", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 7, + "all_observed_lags_weighted": true, + "extra_df": 0, + "design_rank": 3, + "design_columns": 3, + "rank_deficient_extension": false, + "df_scale": 1.0422535211267605 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "12c33e6f47999010", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-a0098cb9e0ec5789", + "method_config_id": "method-92cf71749956c3e0", + "variant": "pooled-hc0", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 3, + "design_columns": 3 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "f27645ad5de6b6d0", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-a4418dfce7964fe2", + "method_config_id": "method-2f6ff2531b0a6ff2", + "variant": "pooled-hc2", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.014035716007961324, + "leverage_max": 0.2314570623669297 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "caf959da5e6f2e15", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-e8309fa1968918a3", + "method_config_id": "method-55ee08dcdc174db4", + "variant": "pooled-hc3", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.014035716007961324, + "leverage_max": 0.2314570623669297 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "402835db8a76af54", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-2589dbc750e59c4e", + "method_config_id": "method-10962eabf3c4e7e5", + "variant": "pooled-legacy-hac", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hac", + "kernel": "bartlett", + "bandwidth": 2, + "row_order_hac": true + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "726496674d73ac3a", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-4396be726373163f", + "method_config_id": "method-d0fe2c5321adee4b", + "variant": "random-effects-cluster-two-way", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 2, + "cluster_group_counts": [ + 10, + 8, + 74 + ], + "group_debias": true, + "group_debias_factors": [ + 1.0960960960960962, + 1.1274131274131274, + 1.0 + ] + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "87e9e6885219c2bd", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-0932beff1128acfc", + "method_config_id": "method-3c277698526e33ed", + "variant": "random-effects-dk", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "parzen", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 2, + "all_observed_lags_weighted": false, + "extra_df": 0, + "design_rank": 3, + "design_columns": 3, + "rank_deficient_extension": false, + "df_scale": 1.0422535211267605 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "e97eb799f68f65a1", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-fb86972c1f229ddc", + "method_config_id": "method-bc1f5572ac47be2d", + "variant": "random-effects-explicit-constant-hc0", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 3, + "design_columns": 3 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "16f78c2c37734b86", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-3b6202a899b202c5", + "method_config_id": "method-46a1efed634b9b1f", + "variant": "random-effects-explicit-constant-hc2", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.013773465636365006, + "leverage_max": 0.23398280044939515 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "148b7c66e46e15ee", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-0ad05ccdc588c746", + "method_config_id": "method-d1a58746479cc13a", + "variant": "random-effects-explicit-constant-hc3", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.013773465636365006, + "leverage_max": 0.23398280044939515 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "d6760461bcf453a2", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-db82aa7c776f16f8", + "method_config_id": "method-fc7155cf722559da", + "variant": "random-effects-explicit-constant-robust", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "robust", + "hc_equivalent": "hc1", + "hc1_correction": 1.0422535211267605 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "d1d70464c8cde08f", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelCovariancePrimitive", + "case_id": "case-d861c0bd35587898", + "method_config_id": "method-39dcc17d65e965a1", + "variant": "public-cluster-group-debias", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "public_primitive_physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch" + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "primitive_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "db325d66b444d39b", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelCovariancePrimitive", + "case_id": "case-da574a2931912ff2", + "method_config_id": "method-c1dd4f1273777fd3", + "variant": "public-driscoll-kraay-qs", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "public_primitive_physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch" + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "primitive_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "c056a8f65d3c6aa0", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelCovariancePrimitive", + "case_id": "case-d88f200f76d48e35", + "method_config_id": "method-337a25a54644be63", + "variant": "public-ill-conditioned-dk", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "public_primitive_physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch" + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "primitive_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "9226d478e88f9390", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelCovariancePrimitive", + "case_id": "case-3ae6fa564570f286", + "method_config_id": "method-44c3dcff21d4b8c4", + "variant": "public-ill-conditioned-hc0", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "public_primitive_physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch" + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "primitive_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "e61ff5b46036dbaa", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelCovariancePrimitive", + "case_id": "case-ed533f11c321fa36", + "method_config_id": "method-51303a8fd255c778", + "variant": "public-ill-conditioned-hc2", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "public_primitive_physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch" + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "primitive_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "0d732c2f70b29fb8", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelCovariancePrimitive", + "case_id": "case-adef450c1b1b2a5c", + "method_config_id": "method-ba1967a3dab3096e", + "variant": "public-ill-conditioned-hc3", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "public_primitive_physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch" + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "primitive_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "4f624709579f269a", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-1d090b237cefeeae", + "method_config_id": "method-4cb650a8f1e99aa3", + "variant": "pooled-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 7.40537, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "0c9c67295fc55e53", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-898bc63088d56336", + "method_config_id": "method-ea7f8f0647dc8db7", + "variant": "pooled-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 6.349415, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "ec3e4c99d0556cdd", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-726cc1f2ec63f4f1", + "method_config_id": "method-38b70f7a04ebe52e", + "variant": "pooled-cluster-two-way-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 16.390175, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "86d66d5298c468b7", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-41c1f2d4d22a5f92", + "method_config_id": "method-ae65884e9fe580ec", + "variant": "pooled-dk-qs-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 8.806497, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "0e8445ee71a212d3", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-f0eb758ee66ffc2a", + "method_config_id": "method-16853a21c5306b61", + "variant": "panel-entity-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 18.040448, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "94c9064e41d4993b", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-1df7d2f41dadfc41", + "method_config_id": "method-da54d4fe530150fd", + "variant": "panel-entity-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 14.901578, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "17529b9ac7b1df00", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-904d3d581ee45dae", + "method_config_id": "method-961baa3544d9c44f", + "variant": "panel-entity-dk-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 16.945034, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "d2b3f6ffca334d4b", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-b13f5f05c8ab64a0", + "method_config_id": "method-3648257d1f81394d", + "variant": "random-effects-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 21.593332, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "a5cbb6dc66b42e02", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-e899613b59ea8393", + "method_config_id": "method-89c2b55373d9a651", + "variant": "random-effects-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 18.275231, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "610667a6fbb04dc9", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-1d090b237cefeeae", + "method_config_id": "method-4cb650a8f1e99aa3", + "variant": "pooled-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 8.874416, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "2d83f6b75e47a186", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-898bc63088d56336", + "method_config_id": "method-ea7f8f0647dc8db7", + "variant": "pooled-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 7.452756, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "eb658bf4e8746ddb", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-726cc1f2ec63f4f1", + "method_config_id": "method-38b70f7a04ebe52e", + "variant": "pooled-cluster-two-way-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 18.415928, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "8f49882858f4dda0", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-41c1f2d4d22a5f92", + "method_config_id": "method-ae65884e9fe580ec", + "variant": "pooled-dk-qs-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 9.230375, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "460b3f6ab2138b3f", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-f0eb758ee66ffc2a", + "method_config_id": "method-16853a21c5306b61", + "variant": "panel-entity-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 16.233951, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "ebc542a53924d20d", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-1df7d2f41dadfc41", + "method_config_id": "method-da54d4fe530150fd", + "variant": "panel-entity-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 13.368249, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "3a812f22acb1df8e", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-904d3d581ee45dae", + "method_config_id": "method-961baa3544d9c44f", + "variant": "panel-entity-dk-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 15.267581, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "bd941aad1c618809", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-b13f5f05c8ab64a0", + "method_config_id": "method-3648257d1f81394d", + "variant": "random-effects-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 19.914806, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "2a17aedd4926565d", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-e899613b59ea8393", + "method_config_id": "method-89c2b55373d9a651", + "variant": "random-effects-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 16.228199, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "faed5dca4639b9bc", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-9ba5fc363128500e", + "method_config_id": "method-4cb650a8f1e99aa3", + "variant": "pooled-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 10.364473, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "8b75d47eef110886", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-aa55899b9cc7d438", + "method_config_id": "method-ea7f8f0647dc8db7", + "variant": "pooled-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 8.398741, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "f746bb02cf80a30b", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-8e959d7e7cd3bb4e", + "method_config_id": "method-38b70f7a04ebe52e", + "variant": "pooled-cluster-two-way-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 80.644518, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "de4661dfe8f9a383", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-d299c5ace60ec824", + "method_config_id": "method-ae65884e9fe580ec", + "variant": "pooled-dk-qs-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 14.240891, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "02029156923e2624", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-f861a87641327457", + "method_config_id": "method-16853a21c5306b61", + "variant": "panel-entity-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 55.529892, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "0abf93041996905a", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-c26b9174a8c24e8a", + "method_config_id": "method-da54d4fe530150fd", + "variant": "panel-entity-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 41.338086, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "162b231de02b5515", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-caa6c88c3baebd12", + "method_config_id": "method-961baa3544d9c44f", + "variant": "panel-entity-dk-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 55.884361, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "fb6f143b25dc5aff", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-8f1c4eedd7a26b44", + "method_config_id": "method-3648257d1f81394d", + "variant": "random-effects-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 71.11299, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "36df53ff8924ce77", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-a771e7e7103cf44c", + "method_config_id": "method-89c2b55373d9a651", + "variant": "random-effects-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 58.420837, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "a695a9950b5a4006", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-9ba5fc363128500e", + "method_config_id": "method-4cb650a8f1e99aa3", + "variant": "pooled-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 11.348128, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "6d68a4f82432d34d", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-aa55899b9cc7d438", + "method_config_id": "method-ea7f8f0647dc8db7", + "variant": "pooled-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 10.054141, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "83682d43a1a9cc74", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-8e959d7e7cd3bb4e", + "method_config_id": "method-38b70f7a04ebe52e", + "variant": "pooled-cluster-two-way-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 81.151217, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "2fcb2881150fd8b1", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-d299c5ace60ec824", + "method_config_id": "method-ae65884e9fe580ec", + "variant": "pooled-dk-qs-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 15.719026, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "ec38fab2ed594a9e", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-f861a87641327457", + "method_config_id": "method-16853a21c5306b61", + "variant": "panel-entity-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 53.391904, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "e57b812247058c14", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-c26b9174a8c24e8a", + "method_config_id": "method-da54d4fe530150fd", + "variant": "panel-entity-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 39.745837, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "789936199560aea7", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-caa6c88c3baebd12", + "method_config_id": "method-961baa3544d9c44f", + "variant": "panel-entity-dk-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 56.194514, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "8c96e5731939ba41", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-8f1c4eedd7a26b44", + "method_config_id": "method-3648257d1f81394d", + "variant": "random-effects-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 69.751382, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "149681aabfbaf0ba", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-a771e7e7103cf44c", + "method_config_id": "method-89c2b55373d9a651", + "variant": "random-effects-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 57.154447, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "6efe3aa0bd296b97", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-80c431ae56a9f78b", + "method_config_id": "method-4cb650a8f1e99aa3", + "variant": "pooled-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 17.202497, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "e5b37cc3fd9948cb", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-5ee39fefdbc01f9b", + "method_config_id": "method-ea7f8f0647dc8db7", + "variant": "pooled-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 13.465136, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "69f9c145fb3ae841", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-108cadad6b85f7ed", + "method_config_id": "method-38b70f7a04ebe52e", + "variant": "pooled-cluster-two-way-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 84.970236, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "9c9d4e67b1674ec0", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-7359d69ba5607745", + "method_config_id": "method-ae65884e9fe580ec", + "variant": "pooled-dk-qs-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 17.885268, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "c14c03e5bc466af0", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-676e96c03ab116e0", + "method_config_id": "method-16853a21c5306b61", + "variant": "panel-entity-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 127.165198, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "e35f09c6661cb6ce", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-34616e48c43baf8d", + "method_config_id": "method-da54d4fe530150fd", + "variant": "panel-entity-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 93.444109, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "4a0b2a34c3777bb3", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-9c3f5196b502943d", + "method_config_id": "method-961baa3544d9c44f", + "variant": "panel-entity-dk-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 106.719971, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "c07edbeea474c8ed", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-c22aa179b190305a", + "method_config_id": "method-3648257d1f81394d", + "variant": "random-effects-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 198.564678, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "5b0a681d66de4561", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-b5500e401b5189e0", + "method_config_id": "method-89c2b55373d9a651", + "variant": "random-effects-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 162.594855, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "1562fa3246108787", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-80c431ae56a9f78b", + "method_config_id": "method-4cb650a8f1e99aa3", + "variant": "pooled-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 16.992331, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "e82e004e0f88f16a", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-5ee39fefdbc01f9b", + "method_config_id": "method-ea7f8f0647dc8db7", + "variant": "pooled-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 15.967458, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "e1f44d114bdaf44f", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-108cadad6b85f7ed", + "method_config_id": "method-38b70f7a04ebe52e", + "variant": "pooled-cluster-two-way-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 94.817191, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "effa0fca38050c3b", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-7359d69ba5607745", + "method_config_id": "method-ae65884e9fe580ec", + "variant": "pooled-dk-qs-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 21.719575, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "b33caf53a5e1a119", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-676e96c03ab116e0", + "method_config_id": "method-16853a21c5306b61", + "variant": "panel-entity-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 131.193608, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "577d3d9b94277590", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-34616e48c43baf8d", + "method_config_id": "method-da54d4fe530150fd", + "variant": "panel-entity-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 97.770095, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "4e3dba1d6120f639", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-9c3f5196b502943d", + "method_config_id": "method-961baa3544d9c44f", + "variant": "panel-entity-dk-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 110.073924, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "87f1ec2b0d62e8ca", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-c22aa179b190305a", + "method_config_id": "method-3648257d1f81394d", + "variant": "random-effects-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 187.036127, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "363c45696958793f", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-b5500e401b5189e0", + "method_config_id": "method-89c2b55373d9a651", + "variant": "random-effects-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 156.85311, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "1c49ebc0a907f25c", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-ec5ad348723900db", + "method_config_id": "method-ae65884e9fe580ec", + "variant": "pooled-dk-qs-high-t-qs", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n10000_p2_t200", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=200" + }, + "parameters": { + "scenario": "high_t_qs", + "n_times": 200, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 24.67975, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "d125255c0b3ff2ac", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-5ee87f50aa67f37f", + "method_config_id": "method-3dc9c4090e6c2f3b", + "variant": "panel-entity-dk-qs-high-t-qs", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n10000_p2_t200", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=200" + }, + "parameters": { + "scenario": "high_t_qs", + "n_times": 200, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 33.590049, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "56621e7dcbbe8917", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-ec5ad348723900db", + "method_config_id": "method-ae65884e9fe580ec", + "variant": "pooled-dk-qs-high-t-qs", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n10000_p2_t200", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=200" + }, + "parameters": { + "scenario": "high_t_qs", + "n_times": 200, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 17.333329, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "190434a99eb5f7ed", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-5ee87f50aa67f37f", + "method_config_id": "method-3dc9c4090e6c2f3b", + "variant": "panel-entity-dk-qs-high-t-qs", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n10000_p2_t200", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=200" + }, + "parameters": { + "scenario": "high_t_qs", + "n_times": 200, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 24.56376, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" } ] } \ 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 68a6a5657..79d7963ef 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": 11, - "files_parsed": 11, + "files_seen": 13, + "files_parsed": 13, "files_skipped": 0, - "runs_generated": 1862, - "generation_id": "b425b95947fcb5ee7dcd4e6e10f1b108cfe82b804f5d46428e63c1fb5ca35b1d", + "runs_generated": 1984, + "generation_id": "3fd0701c8d8672eecd804b953ebbdd87f8fa9004d7953be496305ddb6164d3a2", "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 efd33ae22..be6bbc232 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": "c9c6655a95d2347de0344a9431f75ec3b218c0b70a8c842719b2f5b8174bed54", + "catalog_digest": "87e34a85b6e6577696e647d12950ebba87867c66f70c9899936f158311bc410a", "coverage_matrix_version": "1.0", - "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, + "coverage_matrix_digest": "06536b7f50bdb3a3554c40fb561d9712ca2f46032f51455f27793ddc321ff5e6", + "discovered_json_artifacts": 101, + "classified_candidate_sources": 101, + "eligible_sources": 13, + "registered_sources": 13, + "available_registered_sources": 13, + "parsed_registered_sources": 13, "eligible_unregistered_sources": 0, "not_canonical_ready_sources": 45, - "historical_or_excluded_sources": 39, + "historical_or_excluded_sources": 43, "superseded_or_duplicate_sources": 10, "unrelated_json_artifacts": 0, "unclassified_artifacts": 0, @@ -1332,6 +1332,114 @@ "issue": "#93", "rule_id": "pr122-panel-stage-b-physical-validation" }, + { + "path": "results/pr126_p100/panel_stage_c_gpu_validation_9c0b3050.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/pr126_p100/panel_stage_c_gpu_validation_aad53587.json", + "artifact_type": "json", + "source_date": "2026-08-10", + "classification": "registered_canonical", + "canonical_eligible": true, + "registered": true, + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "parser": "panel_stage_c_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/pr126_p100/panel_stage_c_gpu_validation_c151550a.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/pr126_p100/panel_stage_c_performance_9c0b3050.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/pr126_p100/panel_stage_c_performance_aad53587.json", + "artifact_type": "json", + "source_date": "2026-08-10", + "classification": "registered_canonical", + "canonical_eligible": true, + "registered": true, + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "parser": "panel_stage_c_performance", + "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/pr126_p100/panel_stage_c_performance_c151550a.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/pr74_inference_validation.json", "artifact_type": "json", @@ -1735,5 +1843,5 @@ "current_evidence_not_canonical_ready": 2, "partial_canonical": 7 }, - "generation_id": "b425b95947fcb5ee7dcd4e6e10f1b108cfe82b804f5d46428e63c1fb5ca35b1d" + "generation_id": "3fd0701c8d8672eecd804b953ebbdd87f8fa9004d7953be496305ddb6164d3a2" } \ No newline at end of file diff --git a/docs/cn/changelog.md b/docs/cn/changelog.md index 098c4abb0..e6d7c6d05 100644 --- a/docs/cn/changelog.md +++ b/docs/cn/changelog.md @@ -1,10 +1,18 @@ # Changelog > 语言：中文
-> 最后更新：2026-08-09
+> 最后更新：2026-08-10
> 页面定位：变更记录
> 切换：[English](../en/changelog.md) +## 2026-08-09 — Panel Stage C 协方差补齐（PR #126） + +Stage C 在不改变 estimator coefficient 与 Stage-B diagnostic definition 的前提下扩展 Panel Tier-1 inference。`robust` 继续表示历史 HC1；新增 `hc0`、`hc2`、`hc3` 按各 estimator 的实际 transformed fit space 计算。`RandomEffects` 支持 quasi-demeaned GLS score 上的 robust/HC、clustered 与 Driscoll-Kraay covariance；one-/two-way cluster 的 `group_debias=True` 为显式 opt-in，默认 clustered 结果保持不变。`PooledOLS(cov_type="hac")` 仍是历史 row-order Bartlett/Newey-West 路径。 + +修复后的 covariance 实现从 design pseudoinverse 构造 bread 与 influence row，以 `diag(X X+)` 计算 HC2/HC3 leverage，统一验证 entity/time/cluster metadata，保持 CuPy group scatter-add 后端原生，发布共享 inference result contract，恢复 RandomEffects formula 的 intercept/feature-name 语义，并对超大 bandwidth 下的 quadratic-spectral weight 使用稳定的小参数展开。外部定义继续对齐固定版本的 `statsmodels`、`linearmodels` 以及 R `sandwich`/`plm`。 + +Fresh physical CUDA 验收已在精确且干净的实现提交 `aad53587c9611da0e71a676e86ef32d9f6403f5c` 上使用 Tesla P100-SXM2-16GB 完成。CuPy 与 Torch 各自通过 26 个 estimator covariance case 和 6 个 direct public covariance primitive（每个 backend 32/32），其中包括 full-rank ill-conditioned HC0/HC2/HC3 与 Driscoll-Kraay，并验证 requested/executed backend 一致且无数值 CPU fallback。同步 performance 仍覆盖三个基础规模及有界的 `N=10,000`、`k=2`、`T=200` QS all-lag 场景，只记录 timing，不声明 speedup。此前 `c151550a...` 与 `9c0b3050...` 产物继续作为不可变历史证据保留。 + ## 2026-08-08 ### PR #122 — Panel Tier-1 diagnostics Stage B diff --git a/docs/cn/models/panel.md b/docs/cn/models/panel.md index 774ed2a45..18c0b7a4c 100644 --- a/docs/cn/models/panel.md +++ b/docs/cn/models/panel.md @@ -1,7 +1,7 @@ # Panel 模型 > 语言：中文 -> 最后更新：2026-08-08 +> 最后更新：2026-08-10 > 页面定位：模型文档 > 切换：[English](../../en/models/panel.md) @@ -18,7 +18,7 @@ 数组输入的数值路径支持 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。 +Tier-1 Panel 路线的 Stage C 在 Stage-B diagnostics 之上补齐 residual-sandwich covariance 层：历史默认行为保持不变，同时加入 HC0/HC2/HC3、RandomEffects robust inference、显式 cluster group debias 与 Driscoll-Kraay，并保持 NumPy/CuPy/Torch 数值累积后端原生。修复后的 covariance/provenance 实现已在 exact-clean head `aad53587...` 上重新完成 Tesla P100 验证：CuPy 与 Torch 各自通过全部 26 个 estimator covariance case 和 6 个 direct public covariance primitive（每个 backend 32/32），包括 full-rank ill-conditioned HC0/HC2/HC3/DK；同步 performance 也覆盖有界的 `N=10,000`、`k=2`、`T=200` QS 场景。此前 `c151550a...` 与 `9c0b3050...` 产物继续作为不可变历史证据保留。 ## 路径 @@ -38,6 +38,7 @@ from statgpu.panel import ( clustered_covariance, two_way_clustered_covariance, hac_covariance, + driscoll_kraay_covariance, ) ``` @@ -45,13 +46,13 @@ from statgpu.panel import ( ## 模型汇总 -| 模型 | 变换 | 主要推断选项 | Stage-B fit statistics | +| 模型 | 变换 | 主要推断选项 | 标准化 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 | +| `PanelOLS` | entity/time 组内变换 | nonrobust；HC0/HC1/HC2/HC3；one-/two-way clustered；Driscoll-Kraay | within/between/overall R²、adjusted R²、classical model F、pooling F | +| `RandomEffects` | Swamy-Arora 可行 GLS | nonrobust；HC0/HC1/HC2/HC3；one-/two-way clustered；Driscoll-Kraay | within/between/overall R²、adjusted R²、classical model F；nonrobust 时可作为 Hausman 输入 | +| `PooledOLS` | 堆叠 OLS | nonrobust；HC0/HC1/HC2/HC3；clustered；legacy row-HAC；Driscoll-Kraay | overall R² 始终可用；提供 `entity_ids` 后增加 within/between R² 与 BP-LM；另有 adjusted R² 和 classical model F | +| `BetweenOLS` | entity 均值 | nonrobust；HC0/HC1/HC2/HC3 | within/between/overall R²、adjusted R²、classical model F | +| `FirstDifferenceOLS` | entity 内一阶差分 | nonrobust；HC0/HC1/HC2/HC3 | within/between/overall R²、差分拟合空间 adjusted R²、classical model F | | `FamaMacBeth` | 逐期横截面回归 | nonrobust、Newey-West | 参数型 within/between/overall R²；不定义 residual-OLS adjusted R² 或 model F | ## 核心估计方程 @@ -74,17 +75,72 @@ $$ 其中 \(X^+\) 在需要时表示 Moore-Penrose 伪逆。`BetweenOLS` 对个体均值执行 OLS，`FirstDifferenceOLS` 对 \(\Delta X\) 和 \(\Delta y\) 执行 OLS，`FamaMacBeth` 对逐期系数向量求平均。 -## 协方差与现有推断 +## Stage-C 协方差与推断 + +Stage C 是增量式扩展：系数估计、Stage-B fit statistics 与历史默认推断不改变。协方差名称规范如下。 | `cov_type` | 行为 | |---|---| -| `"nonrobust"` | 经典 OLS 协方差和 t 推断 | -| `"robust"` | HC1 sandwich 协方差和渐近正态推断 | -| `"clustered"` | 在相应 estimator 支持范围内使用聚类稳健协方差 | -| `"hac"` | `PooledOLS` 使用 Bartlett/Newey-West HAC | -| `"newey-west"` | 对 `FamaMacBeth` 系数时间序列应用 HAC | +| `"nonrobust"` | 经典拟合空间 OLS covariance 与 Student-t 推断 | +| `"robust"`、`"hc1"` | 历史 statgpu HC1 sandwich 与渐近正态推断；`hc1` 规范化为 canonical `robust` | +| `"hc0"` | estimator 实际拟合空间上的未缩放 Eicker-White sandwich | +| `"hc2"`、`"hc3"` | estimator 实际拟合空间上的 leverage-adjusted sandwich | +| `"clustered"` | one-/two-way cluster sandwich；支持时可用 `group_debias=True` 显式修正 | +| `"driscoll-kraay"`、`"dk"`、`"kernel"` | 按 time 聚合 score 后计算 Driscoll-Kraay，可选 Bartlett、Parzen、Quadratic Spectral kernel | +| `"hac"` | `PooledOLS` 历史 row-order Bartlett/Newey-West；与 Driscoll-Kraay 明确区分 | +| `"newey-west"` | `FamaMacBeth` 系数路径已有 HAC；不进入 Stage-C residual-OLS covariance 层 | + +### HC0/HC2/HC3 的拟合空间定义 + +设 estimator 实际数值回归使用的 fit-space design 为 `Z`，残差为 `e`，`B=(Z'Z)^+`。leverage 为 + +$$ +h_i=z_i^\top Bz_i. +$$ + +HC0 的 meat 为 $\sum_i z_i z_i^\top e_i^2$；HC2 将每个残差平方除以 $1-h_i$；HC3 除以 $(1-h_i)^2$。实现逐行计算 leverage，不会构造 `n x n` hat matrix。当 leverage 在数值上等于 1 时，HC2/HC3 本身未定义，因此显式报错而不是裁剪成看似有效的 covariance。 + +不同模型使用不同 fit space：`PooledOLS` 为含 fitted intercept 的 level design；`PanelOLS` 为 fixed-effect transformed slope design；`RandomEffects` 为 quasi-demeaned `X_star`；`BetweenOLS` 为 entity-mean design；`FirstDifferenceOLS` 为保留的一阶差分 design。因此 Panel HC2/HC3 明确称为 **transformed-fit-space HC2/HC3**，不会暗中改成完整 dummy regression 的 HC2/HC3。 + +### Cluster covariance 与 `group_debias` + +one-way clustering 在 cluster 内汇总 score vector。two-way clustering 对 cluster 1、cluster 2 与精确 paired-label intersection 做 inclusion-exclusion。默认 `group_debias=False` 完全保留历史 statgpu clustered covariance。设某一 component 有 `G` 个 group，则 `group_debias=True` 会在 inclusion-exclusion 前将该 component 的 meat 乘以 + +$$ +\frac{G}{G-1}\frac{n-1}{n}. +$$ + +这只改变 covariance 大小；Stage C 不会静默把 coefficient test 改成 finite-group t reference。字符串/分类 cluster label 属于 metadata，可在 CPU factorize，但数值 score matrix 不会搬回 CPU。 + +### Driscoll-Kraay covariance + +Driscoll-Kraay 首先按 observed time 聚合 fit-space score： + +$$ +g_t=\sum_i z_{it}e_{it}, +$$ + +再对有序 `g_t` 序列计算 kernel HAC。`PooledOLS` 使用 `time_index=`；`PanelOLS` 与 `RandomEffects` 使用对齐后的 `time_ids=`。unbalanced panel 直接按每个 time 实际存在的观测聚合。 + +对 full-rank fit-space design（列数 `k`），Stage C 使用与 `linearmodels==7.0` 对齐的 debiased scale： + +$$ +\mathrm{scale}_{DK}=\frac{n}{n-\mathrm{extra\_df}-k}. +$$ + +`PooledOLS` 与 `RandomEffects` 的 `extra_df=0`；`PanelOLS` 使用 Stage-B standard fixed-effect nuisance rank（`N`、`T` 或 `N+T-C`）。若 statgpu 合法到达 rank-deficient fit，则记录为扩展：用 numerical rank 替代 `k` 并配合 pseudoinverse；该 corner 不宣称与 `linearmodels` 完全相等。 + +`bandwidth=None` 使用 `floor(4*(T/100)^(2/9))`，其中 `T` 是 observed distinct time period 数。Bartlett/Newey-West 与 Parzen/Gallant 在 bandwidth 处截断。Quadratic Spectral（`qs`、Andrews）把 bandwidth 当作平滑尺度；bandwidth 为正时对**所有 observed lag**赋权，而不是在 `bw` 截断。numeric 与 datetime time key 按自然排序处理；ordered pandas categorical 保留显式声明的 category chronology，并仅压缩实际 observed categories。普通 string/object label 仍采用 deterministic sorted-label order；若时间顺序与字典序不同，应传入 ordered categorical 或显式 numeric/datetime time key。 + +### RandomEffects covariance -Stage B 不修改原有 `bse_`、`tvalues_`、`pvalues_`、`conf_int_` 或 estimator-specific covariance 定义。RandomEffects robust covariance、HC0/HC2/HC3、Driscoll-Kraay 和扩展 cluster correction 仍属于后续 Stage C。 +Stage C 不改变 Swamy-Arora variance component 或 coefficient estimate。robust、HC、cluster 与 Driscoll-Kraay 都基于 quasi-demeaned GLS design `X_star` 与相应 residual 计算，因此改变 `cov_type` 只改变 inference。Stage-B classical Hausman 要求 **FE 与 RE 两端都使用 nonrobust covariance**；robust auxiliary Hausman 不在 Stage C 范围内，并返回结构化 inapplicable 结果。 + +### Backend 与验证状态 + +HC leverage、row score、cluster/time grouped score、lag product、bread/meat/covariance 都保留在 NumPy/CuPy/Torch 数值后端。CPU transfer 只允许 label/group code、小型配置和 scalar audit reduction。显式 GPU device 不静默回退 CPU。 + +hosted Stage-C tests 已将 HC2/HC3 与 analytic/statsmodels fit-space 计算对齐，并将 cluster/Driscoll-Kraay definition 与 `linearmodels==7.0` 固定版本对齐。fresh exact-clean head `aad53587...` 的 Tesla P100 acceptance 已闭合：CuPy 与 Torch 每个 backend 均通过 26/26 estimator covariance case 与 6/6 direct public covariance primitive（每个 backend 32/32），包括 full-rank ill-conditioned HC0/HC2/HC3/DK regressions，requested/executed backend 一致且无 CPU fallback。同步 performance rerun 覆盖三个 base scale 以及显式 `N=10,000`、`k=2`、`T=200` QS all-lag 场景，只记录 timing，不声明 speedup；此前 `c151550a...` 与 `9c0b3050...` 产物继续作为历史审计证据。 ### PooledOLS HAC 时间排序 @@ -238,6 +294,7 @@ $$ - FE 必须只有 one-way entity effects； - FE coefficient covariance 必须是 classical/nonrobust； +- RE coefficient covariance 同样必须是 classical/nonrobust；Stage-C robust/HC/cluster/DK RE fit 不属于该 classical test 的输入； - 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； @@ -258,7 +315,10 @@ GPU 拟合下，canonical slope full-content digest 仅为了 hashing 而通过 PanelOLS( entity_effects=False, time_effects=False, - cov_type="nonrobust", + cov_type="nonrobust", # 同时支持 robust/hc0/hc1/hc2/hc3/clustered/dk + bandwidth=None, + kernel="bartlett", + group_debias=False, device="auto", ) ``` @@ -273,10 +333,11 @@ formula 输入也可使用已有 pipe syntax，例如 `"y ~ x1 + x2 | entity"` ```python PooledOLS( - cov_type="nonrobust", + cov_type="nonrobust", # 包含 HC、clustered、legacy hac 与 dk alpha=0.05, bandwidth=None, kernel="bartlett", + group_debias=False, device="auto", ) ``` @@ -296,9 +357,15 @@ clustered inference 需要 `cluster`。`time_index` 定义 HAC 的稳定时间 ### 其他模型 ```python -RandomEffects(device="auto") -BetweenOLS(cov_type="nonrobust", alpha=0.05, device="auto") -FirstDifferenceOLS(cov_type="nonrobust", alpha=0.05, device="auto") +RandomEffects( + device="auto", + cov_type="nonrobust", # robust/hc0/hc1/hc2/hc3/clustered/dk + bandwidth=None, + kernel="bartlett", + group_debias=False, +) +BetweenOLS(cov_type="nonrobust", alpha=0.05, device="auto") # 支持 HC0/1/2/3 +FirstDifferenceOLS(cov_type="nonrobust", alpha=0.05, device="auto") # 支持 HC0/1/2/3 FamaMacBeth( cov_type="newey-west", bandwidth=None, diff --git a/docs/en/changelog.md b/docs/en/changelog.md index bba565eee..26c62fb58 100644 --- a/docs/en/changelog.md +++ b/docs/en/changelog.md @@ -1,10 +1,18 @@ # Changelog > Language: English
-> Last updated: 2026-08-09
+> Last updated: 2026-08-10
> This page: Changelog
> Switch: [Chinese](../cn/changelog.md) +## 2026-08-09 — Panel Stage C covariance completion (PR #126) + +Stage C extends the Panel Tier-1 inference layer without changing estimator coefficients or the Stage-B diagnostic definitions. `robust` remains the historical HC1 contract; new `hc0`, `hc2`, and `hc3` use each estimator's actual transformed fit space. `RandomEffects` supports robust/HC, clustered, and Driscoll-Kraay covariance on the quasi-demeaned GLS scores. One-/two-way clustering has opt-in `group_debias=True`; the default clustered result is unchanged. `PooledOLS(cov_type="hac")` remains the legacy row-order Bartlett/Newey-West path. + +The repaired covariance implementation derives bread and influence rows from the design pseudoinverse, computes HC2/HC3 leverage from `diag(X X+)`, validates entity/time/cluster metadata consistently, keeps CuPy group scatter-add backend-native, publishes the shared inference result contract, preserves RandomEffects formula intercept and feature names, and stabilizes quadratic-spectral weights for very large bandwidths. External definitions are checked against pinned `statsmodels`, `linearmodels`, and R `sandwich`/`plm` references. + +Fresh physical CUDA acceptance completed on exact clean implementation head `aad53587c9611da0e71a676e86ef32d9f6403f5c` using Tesla P100-SXM2-16GB. CuPy and Torch each pass all 26 estimator covariance cases plus 6 direct public covariance primitives (32/32 per backend), including full-rank ill-conditioned HC0/HC2/HC3 and Driscoll-Kraay cases, with requested/executed backend identity and no numerical CPU fallback. The synchronized performance run retains the three base scales and bounded `N=10,000`, `k=2`, `T=200` QS all-lag scenario; it records timing only and makes no speedup claim. Earlier `c151550a...` and `9c0b3050...` artifacts are retained as immutable historical evidence. + ## 2026-08-08 ### PR #122 — Panel Tier-1 diagnostics Stage B diff --git a/docs/en/models/panel.md b/docs/en/models/panel.md index 267e5ae52..1019e4436 100644 --- a/docs/en/models/panel.md +++ b/docs/en/models/panel.md @@ -1,7 +1,7 @@ # Panel Models > Language: English -> Last updated: 2026-08-08 +> Last updated: 2026-08-10 > This page: Model documentation > Switch: [Chinese](../../cn/models/panel.md) @@ -18,7 +18,7 @@ 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. +Stage C of the Tier-1 panel roadmap completes the residual-sandwich covariance layer on top of the Stage-B diagnostics: historical defaults remain unchanged, while HC0/HC2/HC3, robust RandomEffects inference, explicit cluster group debiasing, and Driscoll-Kraay covariance are added with NumPy/CuPy/Torch-native accumulation. The repaired covariance/provenance implementation was revalidated on exact-clean head `aad53587...` using Tesla P100: CuPy and Torch each pass all 26 estimator covariance cases plus six direct public covariance primitives (32/32 per backend), including full-rank ill-conditioned HC0/HC2/HC3/DK, and the synchronized performance run includes the bounded `N=10,000`, `k=2`, `T=200` QS scenario. Earlier `c151550a...` and `9c0b3050...` artifacts remain immutable historical evidence. ## Paths @@ -38,6 +38,7 @@ from statgpu.panel import ( clustered_covariance, two_way_clustered_covariance, hac_covariance, + driscoll_kraay_covariance, ) ``` @@ -45,13 +46,13 @@ The diagnostic result classes and functions are also exported from top-level `st ## Model Summary -| Model | Transformation | Main inference choices | Stage-B fit statistics | +| Model | Transformation | Main inference choices | Standardized 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 | +| `PanelOLS` | Entity/time within transformation | nonrobust; HC0/HC1/HC2/HC3; one-/two-way clustered; Driscoll-Kraay | within/between/overall R², adjusted R², classical model F, pooling F | +| `RandomEffects` | Swamy-Arora feasible GLS | nonrobust; HC0/HC1/HC2/HC3; one-/two-way clustered; Driscoll-Kraay | within/between/overall R², adjusted R², classical model F, Hausman input when nonrobust | +| `PooledOLS` | Stacked OLS | nonrobust; HC0/HC1/HC2/HC3; clustered; legacy row-HAC; Driscoll-Kraay | overall R² always; within/between R² and BP-LM with `entity_ids`; adjusted R² and classical model F | +| `BetweenOLS` | Entity means | nonrobust; HC0/HC1/HC2/HC3 | within/between/overall R², adjusted R², classical model F | +| `FirstDifferenceOLS` | Within-entity first differences | nonrobust; HC0/HC1/HC2/HC3 | 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 @@ -74,17 +75,72 @@ $$ 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 Existing Inference +## Stage-C Covariance and Inference + +Stage C is additive: coefficient estimation, Stage-B fit statistics, and the historical default inference remain unchanged. Covariance names are normalized as follows. | `cov_type` | Behavior | |---|---| -| `"nonrobust"` | Classical OLS covariance and t-based inference | -| `"robust"` | HC1 sandwich covariance and asymptotic normal inference | -| `"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 | +| `"nonrobust"` | Classical fit-space OLS covariance with Student-t inference | +| `"robust"`, `"hc1"` | The historical statgpu HC1 sandwich with asymptotic normal inference; `hc1` normalizes to canonical `robust` | +| `"hc0"` | Unscaled Eicker-White sandwich on the estimator's actual fit-space regression | +| `"hc2"`, `"hc3"` | Leverage-adjusted sandwich on the estimator's actual fit-space regression | +| `"clustered"` | One- or two-way clustered sandwich; `group_debias=True` opt-in correction where supported | +| `"driscoll-kraay"`, `"dk"`, `"kernel"` | Time-aggregated Driscoll-Kraay covariance with Bartlett, Parzen, or quadratic-spectral kernels | +| `"hac"` | Historical row-order Bartlett/Newey-West covariance for `PooledOLS`; deliberately distinct from Driscoll-Kraay | +| `"newey-west"` | Existing HAC on the `FamaMacBeth` coefficient path; not routed through the residual-OLS Stage-C layer | + +### HC0/HC2/HC3 fit-space definition + +For the numerical regression actually used by an estimator, let `Z` be the fit-space design, `e` the fit-space residual vector, and `B=(Z'Z)^+`. The leverage is + +$$ +h_i=z_i^\top Bz_i. +$$ + +HC0 uses the meat $\sum_i z_i z_i^\top e_i^2$; HC2 divides each squared residual by $1-h_i$; HC3 divides by $(1-h_i)^2$. The implementation computes leverage rowwise and never materializes an `n x n` hat matrix. A numerically unit leverage makes HC2/HC3 undefined and raises rather than being clipped into a valid-looking covariance. + +The fit space is model-specific: pooled level design for `PooledOLS`, fixed-effect transformed slopes for `PanelOLS`, quasi-demeaned `X_star` for `RandomEffects`, entity means for `BetweenOLS`, and retained first differences for `FirstDifferenceOLS`. Consequently Panel HC2/HC3 is documented as **transformed-fit-space HC2/HC3**; it is not silently redefined as HC2/HC3 from a literal full dummy regression. + +### Cluster covariance and `group_debias` + +One-way clustering aggregates score vectors within a cluster. Two-way clustering uses inclusion-exclusion of cluster 1, cluster 2, and the exact paired-label intersection. The default `group_debias=False` preserves the historical statgpu clustered covariance. With `group_debias=True`, each component's meat is multiplied by + +$$ +\frac{G}{G-1}\frac{n-1}{n}, +$$ + +using that component's own group count before two-way inclusion-exclusion. This changes covariance magnitude only; Stage C does not silently switch coefficient tests to a finite-group t reference. String/categorical cluster labels are metadata and are factorized without moving the numerical score matrix to CPU. + +### Driscoll-Kraay covariance + +Driscoll-Kraay first aggregates fit-space scores by observed time, + +$$ +g_t=\sum_i z_{it}e_{it}, +$$ + +then applies a kernel HAC to the ordered `g_t` series. `PooledOLS` uses `time_index=`, while `PanelOLS` and `RandomEffects` use aligned `time_ids=`. Unbalanced panels are supported because each time aggregate contains only observed rows. + +For a full-rank fit-space design with `k` columns, Stage C uses the `linearmodels==7.0`-compatible debiased scale + +$$ +\mathrm{scale}_{DK}=\frac{n}{n-\mathrm{extra\_df}-k}. +$$ + +`PooledOLS` and `RandomEffects` use `extra_df=0`. `PanelOLS` uses the Stage-B standard fixed-effect nuisance rank (`N`, `T`, or `N+T-C`). If statgpu validly reaches a rank-deficient fit, the documented extension replaces `k` by the numerical rank and uses a pseudoinverse; this corner is not claimed to be a `linearmodels` equality case. + +`bandwidth=None` uses `floor(4*(T/100)^(2/9))`, where `T` is the number of distinct observed periods. Bartlett/Newey-West and Parzen/Gallant are truncated at the bandwidth. Quadratic Spectral (`qs`, Andrews) treats bandwidth as a smoothing scale and applies weights to **all observed lags** when bandwidth is positive; it is not truncated at `bw`. Numeric and datetime time keys use their natural sorted order. An ordered pandas categorical preserves its declared category chronology, restricted to observed categories. Plain string/object labels retain deterministic sorted-label ordering; when chronological order differs from lexical order, pass an ordered categorical or an explicit numeric/datetime time key. + +### RandomEffects covariance -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. +Stage C does not alter Swamy-Arora variance-component or coefficient estimation. Robust, HC, cluster, and Driscoll-Kraay covariance are computed from the quasi-demeaned GLS design `X_star` and residuals. Therefore changing `cov_type` changes only inference. The classical Stage-B Hausman test requires **both** the FE and RE fits to use nonrobust covariance; robust auxiliary Hausman remains out of scope and returns a structured inapplicable result. + +### Backend and validation status + +HC leverage, row scores, grouped cluster/time scores, lag products, bread/meat matrices, and covariance accumulation remain on NumPy/CuPy/Torch. CPU transfers are restricted to labels/group codes, small configuration, and scalar audit reductions. Explicit GPU devices never silently fall back to CPU. + +Hosted Stage-C tests pin HC2/HC3 against analytic/statsmodels fit-space calculations and cluster/Driscoll-Kraay definitions against `linearmodels==7.0`. Fresh exact-clean-head Tesla P100 acceptance is complete on `aad53587...`: CuPy and Torch each pass 26/26 estimator covariance cases plus 6/6 direct public covariance primitives (32/32 per backend), including the full-rank ill-conditioned HC0/HC2/HC3/DK regressions, with requested/executed backend identity and no CPU fallback. The synchronized performance rerun covers the three base scales and explicit `N=10,000`, `k=2`, `T=200` QS all-lag scenario; it records timing only and makes no speedup claim. The earlier `c151550a...` and `9c0b3050...` artifacts remain historical audit evidence. ### PooledOLS HAC ordering @@ -238,6 +294,7 @@ Applicability rules are explicit: - FE must be one-way entity effects only; - the FE coefficient covariance must be classical/nonrobust; +- the RE coefficient covariance must also be classical/nonrobust; Stage-C robust/HC/cluster/DK RE fits are not inputs to this classical test; - 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; @@ -258,7 +315,10 @@ If the covariance difference is positive semidefinite but rank-deficient, statgp PanelOLS( entity_effects=False, time_effects=False, - cov_type="nonrobust", + cov_type="nonrobust", # robust/hc0/hc1/hc2/hc3/clustered/dk also supported + bandwidth=None, + kernel="bartlett", + group_debias=False, device="auto", ) ``` @@ -273,10 +333,11 @@ Formula input can also request effects through the existing pipe syntax, for exa ```python PooledOLS( - cov_type="nonrobust", + cov_type="nonrobust", # includes HC, clustered, legacy hac, and dk alpha=0.05, bandwidth=None, kernel="bartlett", + group_debias=False, device="auto", ) ``` @@ -296,9 +357,15 @@ model.fit( ### Other models ```python -RandomEffects(device="auto") -BetweenOLS(cov_type="nonrobust", alpha=0.05, device="auto") -FirstDifferenceOLS(cov_type="nonrobust", alpha=0.05, device="auto") +RandomEffects( + device="auto", + cov_type="nonrobust", # robust/hc0/hc1/hc2/hc3/clustered/dk + bandwidth=None, + kernel="bartlett", + group_debias=False, +) +BetweenOLS(cov_type="nonrobust", alpha=0.05, device="auto") # HC0/1/2/3 supported +FirstDifferenceOLS(cov_type="nonrobust", alpha=0.05, device="auto") # HC0/1/2/3 supported FamaMacBeth( cov_type="newey-west", bandwidth=None, diff --git a/frontend/public/data/benchmark_data.json b/frontend/public/data/benchmark_data.json index b7b025ba4..d725b3ae7 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": "b425b95947fcb5ee7dcd4e6e10f1b108cfe82b804f5d46428e63c1fb5ca35b1d" + "generation_id": "3fd0701c8d8672eecd804b953ebbdd87f8fa9004d7953be496305ddb6164d3a2" }, "environments": [ { @@ -33,6 +33,12 @@ "label": "Tesla P100 PR #122 Panel Stage B validation — 2026-08-09", "gpu": "Tesla P100-SXM2-16GB", "cpu": "x86_64" + }, + { + "env_id": "remote-p100-pr126-20260810", + "label": "Tesla P100 PR #126 Panel Stage C — 2026-08-10", + "gpu": "Tesla P100-SXM2-16GB", + "cpu": "x86_64" } ], "categories": [ @@ -326,6 +332,15 @@ "supports_penalty": false, "supports_inference": false }, + { + "model_id": "PanelCovariancePrimitive", + "primary_category_id": "panel", + "category_ids": [ + "panel" + ], + "supports_penalty": false, + "supports_inference": true + }, { "model_id": "PanelOLS", "primary_category_id": "panel", @@ -609,6 +624,16 @@ "label": "Panel Stage B physical validation — PR #122 — 2026-08-09", "env_id": "remote-p100-pr122-20260809" }, + { + "comparison_id": "panel-stage-c-pr126-performance-20260810", + "label": "Panel Stage C synchronized performance — PR #126 — 2026-08-10", + "env_id": "remote-p100-pr126-20260810" + }, + { + "comparison_id": "panel-stage-c-pr126-validation-20260810", + "label": "Panel Stage C physical validation — PR #126 — 2026-08-10", + "env_id": "remote-p100-pr126-20260810" + }, { "comparison_id": "penalized-glm-perf-20260622", "label": "Penalized GLM performance — 2026-06-22", @@ -94516,6 +94541,9126 @@ } }, "comparison_id": "panel-stage-b-pr122-20260809" + }, + { + "run_id": "ffa7a2b8ababa030", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "BetweenOLS", + "case_id": "case-602e339be5cd2fa9", + "method_config_id": "method-a09810be8b1ca601", + "variant": "between-hc0", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 3, + "design_columns": 3 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "45afdd869f017422", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "BetweenOLS", + "case_id": "case-69e808d2847ce85d", + "method_config_id": "method-8e0ebf13ace989a2", + "variant": "between-hc2", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.12370974688631295, + "leverage_max": 0.49672782581248387 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "c01ebda399aa0b38", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "BetweenOLS", + "case_id": "case-85cf52cac7d2be79", + "method_config_id": "method-d06f1dd1c3ce3c8a", + "variant": "between-hc3", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.12370974688631295, + "leverage_max": 0.49672782581248387 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "be3ecd88a983f9f8", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "FirstDifferenceOLS", + "case_id": "case-4fdd41d8d1e161ac", + "method_config_id": "method-2f342d8f6ae7ffba", + "variant": "first-difference-hc0", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 2, + "design_columns": 2 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "f1ae74a654ce3239", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "FirstDifferenceOLS", + "case_id": "case-1f138c6d57030c56", + "method_config_id": "method-a32ce6449e2fb8e2", + "variant": "first-difference-hc2", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0006345976206143431, + "leverage_max": 0.20961579624221383 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "c944e7c061446f25", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "FirstDifferenceOLS", + "case_id": "case-eb5e9029d2c5924a", + "method_config_id": "method-afe40611056711c9", + "variant": "first-difference-hc3", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0006345976206143431, + "leverage_max": 0.20961579624221383 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "4e80600d60337aca", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-a11ab9403e16ad92", + "method_config_id": "method-f013c673f09a3863", + "variant": "panel-entity-hc0", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 2, + "design_columns": 2 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "f0cd82270e1c112a", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-1dc8bafefab7ca3d", + "method_config_id": "method-b1cc7e744ee0add7", + "variant": "panel-entity-hc2", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0005744684754546323, + "leverage_max": 0.19529948562793312 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "07ac3fc120801c13", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-f7a19757b7251512", + "method_config_id": "method-7c0a73ca0adc7e40", + "variant": "panel-entity-hc3", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0005744684754546323, + "leverage_max": 0.19529948562793312 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "7418362814172183", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-b5c207c9f8fba578", + "method_config_id": "method-c2cf1012d9478da0", + "variant": "panel-two-way-cluster-group-debias", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 2, + "cluster_group_counts": [ + 10, + 8, + 74 + ], + "group_debias": true, + "group_debias_factors": [ + 1.0960960960960962, + 1.1274131274131274, + 1.0 + ] + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "da0cd0ed92760b3f", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-851139e4ad332095", + "method_config_id": "method-a9001b3fe1061be6", + "variant": "panel-two-way-dk", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "bartlett", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 2, + "all_observed_lags_weighted": false, + "extra_df": 17, + "design_rank": 2, + "design_columns": 2, + "rank_deficient_extension": false, + "df_scale": 1.3454545454545455 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "5e8264632f4940ca", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-e2e124c7ebf4878f", + "method_config_id": "method-8ae1a2e2c28c7bac", + "variant": "panel-two-way-hc3", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0004688530808460156, + "leverage_max": 0.15430313435907284 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "df413c95394908c1", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-0db195a58cc039a1", + "method_config_id": "method-6c71aa40b6ebf75b", + "variant": "pooled-cluster-one-way", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 1, + "cluster_group_counts": [ + 10 + ], + "group_debias": false, + "group_debias_factors": [ + 1.0 + ] + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "78d24d3de926a2b0", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-701bd2295fa58132", + "method_config_id": "method-4a7e6b46a3f858f1", + "variant": "pooled-cluster-two-way-group-debias", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 2, + "cluster_group_counts": [ + 10, + 8, + 74 + ], + "group_debias": true, + "group_debias_factors": [ + 1.0960960960960962, + 1.1274131274131274, + 1.0 + ] + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "1de2cfe03146f43e", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-51336b81abca25e9", + "method_config_id": "method-f15484291b75ee66", + "variant": "pooled-dk-bartlett", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "bartlett", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 2, + "all_observed_lags_weighted": false, + "extra_df": 0, + "design_rank": 3, + "design_columns": 3, + "rank_deficient_extension": false, + "df_scale": 1.0422535211267605 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "07dab7b28df4cdad", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-169288239784647b", + "method_config_id": "method-033b6b6eedcd5542", + "variant": "pooled-dk-qs", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "qs", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 7, + "all_observed_lags_weighted": true, + "extra_df": 0, + "design_rank": 3, + "design_columns": 3, + "rank_deficient_extension": false, + "df_scale": 1.0422535211267605 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "5242322364ff48ba", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-a0098cb9e0ec5789", + "method_config_id": "method-92cf71749956c3e0", + "variant": "pooled-hc0", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 3, + "design_columns": 3 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "d11871839cb7d5dc", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-a4418dfce7964fe2", + "method_config_id": "method-2f6ff2531b0a6ff2", + "variant": "pooled-hc2", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.014035716007961326, + "leverage_max": 0.23145706236692953 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "52a98cc742927c5f", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-e8309fa1968918a3", + "method_config_id": "method-55ee08dcdc174db4", + "variant": "pooled-hc3", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.014035716007961326, + "leverage_max": 0.23145706236692953 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "c890d4732d3d7d98", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-2589dbc750e59c4e", + "method_config_id": "method-10962eabf3c4e7e5", + "variant": "pooled-legacy-hac", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hac", + "kernel": "bartlett", + "bandwidth": 2, + "row_order_hac": true + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "510bc1bf73977f5c", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-4396be726373163f", + "method_config_id": "method-d0fe2c5321adee4b", + "variant": "random-effects-cluster-two-way", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 2, + "cluster_group_counts": [ + 10, + 8, + 74 + ], + "group_debias": true, + "group_debias_factors": [ + 1.0960960960960962, + 1.1274131274131274, + 1.0 + ] + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "38644871822230fd", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-0932beff1128acfc", + "method_config_id": "method-3c277698526e33ed", + "variant": "random-effects-dk", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "parzen", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 2, + "all_observed_lags_weighted": false, + "extra_df": 0, + "design_rank": 3, + "design_columns": 3, + "rank_deficient_extension": false, + "df_scale": 1.0422535211267605 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "d1481eafa864d1cf", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-fb86972c1f229ddc", + "method_config_id": "method-bc1f5572ac47be2d", + "variant": "random-effects-explicit-constant-hc0", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 3, + "design_columns": 3 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "aea44dbf69033fbe", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-3b6202a899b202c5", + "method_config_id": "method-46a1efed634b9b1f", + "variant": "random-effects-explicit-constant-hc2", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.013773465636365004, + "leverage_max": 0.23398280044939512 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "2698547113d08184", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-0ad05ccdc588c746", + "method_config_id": "method-d1a58746479cc13a", + "variant": "random-effects-explicit-constant-hc3", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.013773465636365004, + "leverage_max": 0.23398280044939512 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "7a9e29b07d04373f", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-db82aa7c776f16f8", + "method_config_id": "method-fc7155cf722559da", + "variant": "random-effects-explicit-constant-robust", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy", + "covariance_metadata": { + "covariance": "robust", + "hc_equivalent": "hc1", + "hc1_correction": 1.0422535211267605 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "2d2650a27a735fb5", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelCovariancePrimitive", + "case_id": "case-d861c0bd35587898", + "method_config_id": "method-39dcc17d65e965a1", + "variant": "public-cluster-group-debias", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "public_primitive_physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy" + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "primitive_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "0d9188a5004a4d80", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelCovariancePrimitive", + "case_id": "case-da574a2931912ff2", + "method_config_id": "method-c1dd4f1273777fd3", + "variant": "public-driscoll-kraay-qs", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "public_primitive_physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy" + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "primitive_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "e6dda7f03d0e3dd3", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelCovariancePrimitive", + "case_id": "case-d88f200f76d48e35", + "method_config_id": "method-337a25a54644be63", + "variant": "public-ill-conditioned-dk", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "public_primitive_physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy" + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "primitive_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "b24fb1248903a00f", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelCovariancePrimitive", + "case_id": "case-3ae6fa564570f286", + "method_config_id": "method-44c3dcff21d4b8c4", + "variant": "public-ill-conditioned-hc0", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "public_primitive_physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy" + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "primitive_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "9dcdc5586f15571b", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelCovariancePrimitive", + "case_id": "case-ed533f11c321fa36", + "method_config_id": "method-51303a8fd255c778", + "variant": "public-ill-conditioned-hc2", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "public_primitive_physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy" + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "primitive_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "6f292dd8326640ac", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelCovariancePrimitive", + "case_id": "case-adef450c1b1b2a5c", + "method_config_id": "method-ba1967a3dab3096e", + "variant": "public-ill-conditioned-hc3", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "public_primitive_physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "cupy" + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "primitive_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "17a8c5a4435655b8", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "BetweenOLS", + "case_id": "case-602e339be5cd2fa9", + "method_config_id": "method-a09810be8b1ca601", + "variant": "between-hc0", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 3, + "design_columns": 3 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "3e3610b48d64aaa0", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "BetweenOLS", + "case_id": "case-69e808d2847ce85d", + "method_config_id": "method-8e0ebf13ace989a2", + "variant": "between-hc2", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.12370974688631298, + "leverage_max": 0.49672782581248354 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "751af8349183b4fb", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "BetweenOLS", + "case_id": "case-85cf52cac7d2be79", + "method_config_id": "method-d06f1dd1c3ce3c8a", + "variant": "between-hc3", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.12370974688631298, + "leverage_max": 0.49672782581248354 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "319d1c0aa995c1b8", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "FirstDifferenceOLS", + "case_id": "case-4fdd41d8d1e161ac", + "method_config_id": "method-2f342d8f6ae7ffba", + "variant": "first-difference-hc0", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 2, + "design_columns": 2 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "0bf7c785f74bd217", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "FirstDifferenceOLS", + "case_id": "case-1f138c6d57030c56", + "method_config_id": "method-a32ce6449e2fb8e2", + "variant": "first-difference-hc2", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0006345976206143431, + "leverage_max": 0.20961579624221385 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "b51746170e4e35b3", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "FirstDifferenceOLS", + "case_id": "case-eb5e9029d2c5924a", + "method_config_id": "method-afe40611056711c9", + "variant": "first-difference-hc3", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0006345976206143431, + "leverage_max": 0.20961579624221385 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "bda980ba519d4393", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-a11ab9403e16ad92", + "method_config_id": "method-f013c673f09a3863", + "variant": "panel-entity-hc0", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 2, + "design_columns": 2 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "b49489e9fc0e99df", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-1dc8bafefab7ca3d", + "method_config_id": "method-b1cc7e744ee0add7", + "variant": "panel-entity-hc2", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0005744684754546322, + "leverage_max": 0.19529948562793314 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "d5dd6336c08e5112", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-f7a19757b7251512", + "method_config_id": "method-7c0a73ca0adc7e40", + "variant": "panel-entity-hc3", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0005744684754546322, + "leverage_max": 0.19529948562793314 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "e14c2093aba389c8", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-b5c207c9f8fba578", + "method_config_id": "method-c2cf1012d9478da0", + "variant": "panel-two-way-cluster-group-debias", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 2, + "cluster_group_counts": [ + 10, + 8, + 74 + ], + "group_debias": true, + "group_debias_factors": [ + 1.0960960960960962, + 1.1274131274131274, + 1.0 + ] + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "2b654ec0ebddb497", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-851139e4ad332095", + "method_config_id": "method-a9001b3fe1061be6", + "variant": "panel-two-way-dk", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "bartlett", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 2, + "all_observed_lags_weighted": false, + "extra_df": 17, + "design_rank": 2, + "design_columns": 2, + "rank_deficient_extension": false, + "df_scale": 1.3454545454545455 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "5424c4bdc91deb28", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-e2e124c7ebf4878f", + "method_config_id": "method-8ae1a2e2c28c7bac", + "variant": "panel-two-way-hc3", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.000468853080846015, + "leverage_max": 0.15430313435907278 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "c5d42b360c9f5c62", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-0db195a58cc039a1", + "method_config_id": "method-6c71aa40b6ebf75b", + "variant": "pooled-cluster-one-way", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 1, + "cluster_group_counts": [ + 10 + ], + "group_debias": false, + "group_debias_factors": [ + 1.0 + ] + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "0b42ff8900380638", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-701bd2295fa58132", + "method_config_id": "method-4a7e6b46a3f858f1", + "variant": "pooled-cluster-two-way-group-debias", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 2, + "cluster_group_counts": [ + 10, + 8, + 74 + ], + "group_debias": true, + "group_debias_factors": [ + 1.0960960960960962, + 1.1274131274131274, + 1.0 + ] + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "e3715b101715bee2", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-51336b81abca25e9", + "method_config_id": "method-f15484291b75ee66", + "variant": "pooled-dk-bartlett", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "bartlett", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 2, + "all_observed_lags_weighted": false, + "extra_df": 0, + "design_rank": 3, + "design_columns": 3, + "rank_deficient_extension": false, + "df_scale": 1.0422535211267605 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "e35492d064d0d20e", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-169288239784647b", + "method_config_id": "method-033b6b6eedcd5542", + "variant": "pooled-dk-qs", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "qs", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 7, + "all_observed_lags_weighted": true, + "extra_df": 0, + "design_rank": 3, + "design_columns": 3, + "rank_deficient_extension": false, + "df_scale": 1.0422535211267605 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "12c33e6f47999010", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-a0098cb9e0ec5789", + "method_config_id": "method-92cf71749956c3e0", + "variant": "pooled-hc0", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 3, + "design_columns": 3 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "f27645ad5de6b6d0", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-a4418dfce7964fe2", + "method_config_id": "method-2f6ff2531b0a6ff2", + "variant": "pooled-hc2", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.014035716007961324, + "leverage_max": 0.2314570623669297 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "caf959da5e6f2e15", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-e8309fa1968918a3", + "method_config_id": "method-55ee08dcdc174db4", + "variant": "pooled-hc3", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.014035716007961324, + "leverage_max": 0.2314570623669297 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "402835db8a76af54", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-2589dbc750e59c4e", + "method_config_id": "method-10962eabf3c4e7e5", + "variant": "pooled-legacy-hac", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hac", + "kernel": "bartlett", + "bandwidth": 2, + "row_order_hac": true + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "726496674d73ac3a", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-4396be726373163f", + "method_config_id": "method-d0fe2c5321adee4b", + "variant": "random-effects-cluster-two-way", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 2, + "cluster_group_counts": [ + 10, + 8, + 74 + ], + "group_debias": true, + "group_debias_factors": [ + 1.0960960960960962, + 1.1274131274131274, + 1.0 + ] + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "87e9e6885219c2bd", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-0932beff1128acfc", + "method_config_id": "method-3c277698526e33ed", + "variant": "random-effects-dk", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "parzen", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 2, + "all_observed_lags_weighted": false, + "extra_df": 0, + "design_rank": 3, + "design_columns": 3, + "rank_deficient_extension": false, + "df_scale": 1.0422535211267605 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "e97eb799f68f65a1", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-fb86972c1f229ddc", + "method_config_id": "method-bc1f5572ac47be2d", + "variant": "random-effects-explicit-constant-hc0", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 3, + "design_columns": 3 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "16f78c2c37734b86", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-3b6202a899b202c5", + "method_config_id": "method-46a1efed634b9b1f", + "variant": "random-effects-explicit-constant-hc2", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.013773465636365006, + "leverage_max": 0.23398280044939515 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "148b7c66e46e15ee", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-0ad05ccdc588c746", + "method_config_id": "method-d1a58746479cc13a", + "variant": "random-effects-explicit-constant-hc3", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.013773465636365006, + "leverage_max": 0.23398280044939515 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "d6760461bcf453a2", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-db82aa7c776f16f8", + "method_config_id": "method-fc7155cf722559da", + "variant": "random-effects-explicit-constant-robust", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch", + "covariance_metadata": { + "covariance": "robust", + "hc_equivalent": "hc1", + "hc1_correction": 1.0422535211267605 + } + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "case_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + }, + "inference": { + "ok": true, + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "d1d70464c8cde08f", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelCovariancePrimitive", + "case_id": "case-d861c0bd35587898", + "method_config_id": "method-39dcc17d65e965a1", + "variant": "public-cluster-group-debias", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "public_primitive_physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch" + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "primitive_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "db325d66b444d39b", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelCovariancePrimitive", + "case_id": "case-da574a2931912ff2", + "method_config_id": "method-c1dd4f1273777fd3", + "variant": "public-driscoll-kraay-qs", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "public_primitive_physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch" + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "primitive_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "c056a8f65d3c6aa0", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelCovariancePrimitive", + "case_id": "case-d88f200f76d48e35", + "method_config_id": "method-337a25a54644be63", + "variant": "public-ill-conditioned-dk", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "public_primitive_physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch" + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "primitive_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "9226d478e88f9390", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelCovariancePrimitive", + "case_id": "case-3ae6fa564570f286", + "method_config_id": "method-44c3dcff21d4b8c4", + "variant": "public-ill-conditioned-hc0", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "public_primitive_physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch" + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "primitive_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "e61ff5b46036dbaa", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelCovariancePrimitive", + "case_id": "case-ed533f11c321fa36", + "method_config_id": "method-51303a8fd255c778", + "variant": "public-ill-conditioned-hc2", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "public_primitive_physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch" + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "primitive_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "0d732c2f70b29fb8", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-validation", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelCovariancePrimitive", + "case_id": "case-adef450c1b1b2a5c", + "method_config_id": "method-ba1967a3dab3096e", + "variant": "public-ill-conditioned-hc3", + "penalty": null, + "solver": "physical_validation", + "solver_display": "Physical validation", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n74_p2", + "n_samples": 74, + "n_features": 2, + "label": "74×2" + }, + "parameters": { + "metric_scope": "public_primitive_physical_validation", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "executed_backend": "torch" + }, + "source": { + "file": "panel_stage_c_gpu_validation_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_physical_validation_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "original_path": "", + "sha256": "aab3ac61315b78ecaf04351f2922a444e3f44c587b31f9832ccad32839601b6c" + }, + "metrics": { + "validation": { + "status": "pass", + "checks": [ + { + "metric": "source_status_success", + "status": "pass" + }, + { + "metric": "backend_status_success", + "status": "pass" + }, + { + "metric": "primitive_status_success", + "status": "pass" + }, + { + "metric": "executed_backend_matches_requested", + "status": "pass" + }, + { + "metric": "recorded_numpy_difference_finite", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_gpu_validation_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-validation-20260810" + }, + { + "run_id": "4f624709579f269a", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-1d090b237cefeeae", + "method_config_id": "method-4cb650a8f1e99aa3", + "variant": "pooled-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 7.40537, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "0c9c67295fc55e53", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-898bc63088d56336", + "method_config_id": "method-ea7f8f0647dc8db7", + "variant": "pooled-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 6.349415, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "ec3e4c99d0556cdd", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-726cc1f2ec63f4f1", + "method_config_id": "method-38b70f7a04ebe52e", + "variant": "pooled-cluster-two-way-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 16.390175, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "86d66d5298c468b7", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-41c1f2d4d22a5f92", + "method_config_id": "method-ae65884e9fe580ec", + "variant": "pooled-dk-qs-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 8.806497, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "0e8445ee71a212d3", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-f0eb758ee66ffc2a", + "method_config_id": "method-16853a21c5306b61", + "variant": "panel-entity-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 18.040448, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "94c9064e41d4993b", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-1df7d2f41dadfc41", + "method_config_id": "method-da54d4fe530150fd", + "variant": "panel-entity-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 14.901578, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "17529b9ac7b1df00", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-904d3d581ee45dae", + "method_config_id": "method-961baa3544d9c44f", + "variant": "panel-entity-dk-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 16.945034, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "d2b3f6ffca334d4b", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-b13f5f05c8ab64a0", + "method_config_id": "method-3648257d1f81394d", + "variant": "random-effects-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 21.593332, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "a5cbb6dc66b42e02", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-e899613b59ea8393", + "method_config_id": "method-89c2b55373d9a651", + "variant": "random-effects-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 18.275231, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "610667a6fbb04dc9", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-1d090b237cefeeae", + "method_config_id": "method-4cb650a8f1e99aa3", + "variant": "pooled-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 8.874416, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "2d83f6b75e47a186", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-898bc63088d56336", + "method_config_id": "method-ea7f8f0647dc8db7", + "variant": "pooled-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 7.452756, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "eb658bf4e8746ddb", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-726cc1f2ec63f4f1", + "method_config_id": "method-38b70f7a04ebe52e", + "variant": "pooled-cluster-two-way-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 18.415928, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "8f49882858f4dda0", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-41c1f2d4d22a5f92", + "method_config_id": "method-ae65884e9fe580ec", + "variant": "pooled-dk-qs-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 9.230375, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "460b3f6ab2138b3f", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-f0eb758ee66ffc2a", + "method_config_id": "method-16853a21c5306b61", + "variant": "panel-entity-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 16.233951, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "ebc542a53924d20d", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-1df7d2f41dadfc41", + "method_config_id": "method-da54d4fe530150fd", + "variant": "panel-entity-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 13.368249, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "3a812f22acb1df8e", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-904d3d581ee45dae", + "method_config_id": "method-961baa3544d9c44f", + "variant": "panel-entity-dk-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 15.267581, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "bd941aad1c618809", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-b13f5f05c8ab64a0", + "method_config_id": "method-3648257d1f81394d", + "variant": "random-effects-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 19.914806, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "2a17aedd4926565d", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-e899613b59ea8393", + "method_config_id": "method-89c2b55373d9a651", + "variant": "random-effects-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n10000_p2_t20", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 16.228199, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "faed5dca4639b9bc", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-9ba5fc363128500e", + "method_config_id": "method-4cb650a8f1e99aa3", + "variant": "pooled-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 10.364473, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "8b75d47eef110886", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-aa55899b9cc7d438", + "method_config_id": "method-ea7f8f0647dc8db7", + "variant": "pooled-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 8.398741, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "f746bb02cf80a30b", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-8e959d7e7cd3bb4e", + "method_config_id": "method-38b70f7a04ebe52e", + "variant": "pooled-cluster-two-way-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 80.644518, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "de4661dfe8f9a383", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-d299c5ace60ec824", + "method_config_id": "method-ae65884e9fe580ec", + "variant": "pooled-dk-qs-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 14.240891, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "02029156923e2624", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-f861a87641327457", + "method_config_id": "method-16853a21c5306b61", + "variant": "panel-entity-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 55.529892, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "0abf93041996905a", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-c26b9174a8c24e8a", + "method_config_id": "method-da54d4fe530150fd", + "variant": "panel-entity-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 41.338086, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "162b231de02b5515", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-caa6c88c3baebd12", + "method_config_id": "method-961baa3544d9c44f", + "variant": "panel-entity-dk-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 55.884361, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "fb6f143b25dc5aff", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-8f1c4eedd7a26b44", + "method_config_id": "method-3648257d1f81394d", + "variant": "random-effects-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 71.11299, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "36df53ff8924ce77", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-a771e7e7103cf44c", + "method_config_id": "method-89c2b55373d9a651", + "variant": "random-effects-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 58.420837, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "a695a9950b5a4006", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-9ba5fc363128500e", + "method_config_id": "method-4cb650a8f1e99aa3", + "variant": "pooled-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 11.348128, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "6d68a4f82432d34d", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-aa55899b9cc7d438", + "method_config_id": "method-ea7f8f0647dc8db7", + "variant": "pooled-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 10.054141, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "83682d43a1a9cc74", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-8e959d7e7cd3bb4e", + "method_config_id": "method-38b70f7a04ebe52e", + "variant": "pooled-cluster-two-way-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 81.151217, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "2fcb2881150fd8b1", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-d299c5ace60ec824", + "method_config_id": "method-ae65884e9fe580ec", + "variant": "pooled-dk-qs-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 15.719026, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "ec38fab2ed594a9e", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-f861a87641327457", + "method_config_id": "method-16853a21c5306b61", + "variant": "panel-entity-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 53.391904, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "e57b812247058c14", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-c26b9174a8c24e8a", + "method_config_id": "method-da54d4fe530150fd", + "variant": "panel-entity-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 39.745837, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "789936199560aea7", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-caa6c88c3baebd12", + "method_config_id": "method-961baa3544d9c44f", + "variant": "panel-entity-dk-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 56.194514, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "8c96e5731939ba41", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-8f1c4eedd7a26b44", + "method_config_id": "method-3648257d1f81394d", + "variant": "random-effects-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 69.751382, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "149681aabfbaf0ba", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-a771e7e7103cf44c", + "method_config_id": "method-89c2b55373d9a651", + "variant": "random-effects-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p2_t20", + "n_samples": 100000, + "n_features": 2, + "label": "100K×2 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 57.154447, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "6efe3aa0bd296b97", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-80c431ae56a9f78b", + "method_config_id": "method-4cb650a8f1e99aa3", + "variant": "pooled-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 17.202497, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "e5b37cc3fd9948cb", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-5ee39fefdbc01f9b", + "method_config_id": "method-ea7f8f0647dc8db7", + "variant": "pooled-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 13.465136, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "69f9c145fb3ae841", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-108cadad6b85f7ed", + "method_config_id": "method-38b70f7a04ebe52e", + "variant": "pooled-cluster-two-way-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 84.970236, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "9c9d4e67b1674ec0", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-7359d69ba5607745", + "method_config_id": "method-ae65884e9fe580ec", + "variant": "pooled-dk-qs-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 17.885268, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "c14c03e5bc466af0", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-676e96c03ab116e0", + "method_config_id": "method-16853a21c5306b61", + "variant": "panel-entity-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 127.165198, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "e35f09c6661cb6ce", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-34616e48c43baf8d", + "method_config_id": "method-da54d4fe530150fd", + "variant": "panel-entity-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 93.444109, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "4a0b2a34c3777bb3", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-9c3f5196b502943d", + "method_config_id": "method-961baa3544d9c44f", + "variant": "panel-entity-dk-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 106.719971, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "c07edbeea474c8ed", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-c22aa179b190305a", + "method_config_id": "method-3648257d1f81394d", + "variant": "random-effects-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 198.564678, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "5b0a681d66de4561", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-b5500e401b5189e0", + "method_config_id": "method-89c2b55373d9a651", + "variant": "random-effects-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 162.594855, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "1562fa3246108787", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-80c431ae56a9f78b", + "method_config_id": "method-4cb650a8f1e99aa3", + "variant": "pooled-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 16.992331, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "e82e004e0f88f16a", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-5ee39fefdbc01f9b", + "method_config_id": "method-ea7f8f0647dc8db7", + "variant": "pooled-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 15.967458, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "e1f44d114bdaf44f", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-108cadad6b85f7ed", + "method_config_id": "method-38b70f7a04ebe52e", + "variant": "pooled-cluster-two-way-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 94.817191, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "effa0fca38050c3b", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-7359d69ba5607745", + "method_config_id": "method-ae65884e9fe580ec", + "variant": "pooled-dk-qs-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 21.719575, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "b33caf53a5e1a119", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-676e96c03ab116e0", + "method_config_id": "method-16853a21c5306b61", + "variant": "panel-entity-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 131.193608, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "577d3d9b94277590", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-34616e48c43baf8d", + "method_config_id": "method-da54d4fe530150fd", + "variant": "panel-entity-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 97.770095, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "4e3dba1d6120f639", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-9c3f5196b502943d", + "method_config_id": "method-961baa3544d9c44f", + "variant": "panel-entity-dk-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 110.073924, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "87f1ec2b0d62e8ca", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-c22aa179b190305a", + "method_config_id": "method-3648257d1f81394d", + "variant": "random-effects-nonrobust-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 187.036127, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "363c45696958793f", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "RandomEffects", + "case_id": "case-b5500e401b5189e0", + "method_config_id": "method-89c2b55373d9a651", + "variant": "random-effects-hc3-base", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n100000_p10_t20", + "n_samples": 100000, + "n_features": 10, + "label": "100K×10 · T=20" + }, + "parameters": { + "scenario": "base", + "n_times": 20, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 156.85311, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "1c49ebc0a907f25c", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-ec5ad348723900db", + "method_config_id": "method-ae65884e9fe580ec", + "variant": "pooled-dk-qs-high-t-qs", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n10000_p2_t200", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=200" + }, + "parameters": { + "scenario": "high_t_qs", + "n_times": 200, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 24.67975, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "d125255c0b3ff2ac", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-5ee87f50aa67f37f", + "method_config_id": "method-3dc9c4090e6c2f3b", + "variant": "panel-entity-dk-qs-high-t-qs", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "cupy", + "scale": { + "scale_key": "n10000_p2_t200", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=200" + }, + "parameters": { + "scenario": "high_t_qs", + "n_times": 200, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 33.590049, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "56621e7dcbbe8917", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PooledOLS", + "case_id": "case-ec5ad348723900db", + "method_config_id": "method-ae65884e9fe580ec", + "variant": "pooled-dk-qs-high-t-qs", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n10000_p2_t200", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=200" + }, + "parameters": { + "scenario": "high_t_qs", + "n_times": 200, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 17.333329, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" + }, + { + "run_id": "190434a99eb5f7ed", + "benchmark_session_id": "remote-p100-pr126-20260810-panel-stage-c-pr126-performance", + "env_id": "remote-p100-pr126-20260810", + "category_ids": [ + "panel" + ], + "model_id": "PanelOLS", + "case_id": "case-5ee87f50aa67f37f", + "method_config_id": "method-3dc9c4090e6c2f3b", + "variant": "panel-entity-dk-qs-high-t-qs", + "penalty": null, + "solver": "covariance_fit", + "solver_display": "Covariance fit", + "solver_kind": "internal", + "framework": "statgpu", + "backend": "torch", + "scale": { + "scale_key": "n10000_p2_t200", + "n_samples": 10000, + "n_features": 2, + "label": "10K×2 · T=200" + }, + "parameters": { + "scenario": "high_t_qs", + "n_times": 200, + "repeats": 3, + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "measurement_git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true + }, + "source": { + "file": "panel_stage_c_performance_aad53587.json", + "date": "2026-08-10", + "parser": "parse_panel_stage_c_performance_v1", + "parser_version": "1.0", + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "original_path": "", + "sha256": "99208f9276b92abf212d76655616718980095ba5c8ff9d3356a795a15ffa50c6" + }, + "metrics": { + "timing": { + "fit_time_ms": 24.56376, + "quality": "measured", + "source_file": "panel_stage_c_performance_aad53587.json" + }, + "validation": { + "status": "pass", + "checks": [ + { + "metric": "synchronized_timing", + "status": "pass" + }, + { + "metric": "raw_samples_finite_positive", + "status": "pass" + }, + { + "metric": "median_matches_raw_samples", + "status": "pass" + } + ], + "quality": "reported", + "source_file": "panel_stage_c_performance_aad53587.json" + } + }, + "comparison_id": "panel-stage-c-pr126-performance-20260810" } ] } \ No newline at end of file diff --git a/frontend/public/data/parse_report.json b/frontend/public/data/parse_report.json index 68a6a5657..79d7963ef 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": 11, - "files_parsed": 11, + "files_seen": 13, + "files_parsed": 13, "files_skipped": 0, - "runs_generated": 1862, - "generation_id": "b425b95947fcb5ee7dcd4e6e10f1b108cfe82b804f5d46428e63c1fb5ca35b1d", + "runs_generated": 1984, + "generation_id": "3fd0701c8d8672eecd804b953ebbdd87f8fa9004d7953be496305ddb6164d3a2", "issues": [ { "source_id": "glm-solver-20260623-1b6197d94d88", diff --git a/frontend/public/data/source_inventory.json b/frontend/public/data/source_inventory.json index efd33ae22..be6bbc232 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": "c9c6655a95d2347de0344a9431f75ec3b218c0b70a8c842719b2f5b8174bed54", + "catalog_digest": "87e34a85b6e6577696e647d12950ebba87867c66f70c9899936f158311bc410a", "coverage_matrix_version": "1.0", - "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, + "coverage_matrix_digest": "06536b7f50bdb3a3554c40fb561d9712ca2f46032f51455f27793ddc321ff5e6", + "discovered_json_artifacts": 101, + "classified_candidate_sources": 101, + "eligible_sources": 13, + "registered_sources": 13, + "available_registered_sources": 13, + "parsed_registered_sources": 13, "eligible_unregistered_sources": 0, "not_canonical_ready_sources": 45, - "historical_or_excluded_sources": 39, + "historical_or_excluded_sources": 43, "superseded_or_duplicate_sources": 10, "unrelated_json_artifacts": 0, "unclassified_artifacts": 0, @@ -1332,6 +1332,114 @@ "issue": "#93", "rule_id": "pr122-panel-stage-b-physical-validation" }, + { + "path": "results/pr126_p100/panel_stage_c_gpu_validation_9c0b3050.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/pr126_p100/panel_stage_c_gpu_validation_aad53587.json", + "artifact_type": "json", + "source_date": "2026-08-10", + "classification": "registered_canonical", + "canonical_eligible": true, + "registered": true, + "source_id": "panel-stage-c-validation-pr126-20260810-aab3ac61315b", + "parser": "panel_stage_c_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/pr126_p100/panel_stage_c_gpu_validation_c151550a.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/pr126_p100/panel_stage_c_performance_9c0b3050.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/pr126_p100/panel_stage_c_performance_aad53587.json", + "artifact_type": "json", + "source_date": "2026-08-10", + "classification": "registered_canonical", + "canonical_eligible": true, + "registered": true, + "source_id": "panel-stage-c-performance-pr126-20260810-99208f9276b9", + "parser": "panel_stage_c_performance", + "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/pr126_p100/panel_stage_c_performance_c151550a.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/pr74_inference_validation.json", "artifact_type": "json", @@ -1735,5 +1843,5 @@ "current_evidence_not_canonical_ready": 2, "partial_canonical": 7 }, - "generation_id": "b425b95947fcb5ee7dcd4e6e10f1b108cfe82b804f5d46428e63c1fb5ca35b1d" + "generation_id": "3fd0701c8d8672eecd804b953ebbdd87f8fa9004d7953be496305ddb6164d3a2" } \ No newline at end of file diff --git a/results/pr126_p100/panel_stage_c_gpu_validation_9c0b3050.json b/results/pr126_p100/panel_stage_c_gpu_validation_9c0b3050.json new file mode 100644 index 000000000..fe015f03f --- /dev/null +++ b/results/pr126_p100/panel_stage_c_gpu_validation_9c0b3050.json @@ -0,0 +1,1834 @@ +{ + "schema_version": 1, + "generated_at": "2026-08-10T01:55:09.860365Z", + "git_sha": "9c0b3050dd143c43a06bb6393d69f4f83e861637", + "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 + }, + "dataset": { + "nobs": 74, + "n_entities": 10, + "n_times": 8, + "n_features": 2, + "unbalanced": true + }, + "case_count_per_backend": 26, + "public_primitive_count_per_backend": 2, + "backends": { + "cupy": { + "status": "success", + "requested_backend": "cupy", + "cases": { + "pooled_hc0": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 3.469446951953614e-18, + "tvalues": 3.552713678800501e-15, + "pvalues": 3.729655473350135e-17, + "conf_int": 1.1102230246251565e-16, + "covariance": 3.2526065174565133e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0 + }, + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 3, + "design_columns": 3 + } + }, + "pooled_hc2": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 6.938893903907228e-18, + "tvalues": 1.7763568394002505e-15, + "pvalues": 3.9898639947466563e-17, + "conf_int": 1.1102230246251565e-16, + "covariance": 2.303929616531697e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 0.0, + "covariance_metadata.leverage_max": 0.0 + }, + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.014035716007961323, + "leverage_max": 0.23145706236692962 + } + }, + "pooled_hc3": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 6.938893903907228e-18, + "tvalues": 3.552713678800501e-15, + "pvalues": 3.9898639947466563e-17, + "conf_int": 1.1102230246251565e-16, + "covariance": 4.336808689942018e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 0.0, + "covariance_metadata.leverage_max": 0.0 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.014035716007961323, + "leverage_max": 0.23145706236692962 + } + }, + "pooled_cluster_one_way": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 6.938893903907228e-18, + "tvalues": 6.661338147750939e-16, + "pvalues": 3.0531133177191805e-16, + "conf_int": 2.220446049250313e-16, + "covariance": 8.673617379884035e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.cluster_dimensions": 0.0, + "covariance_metadata.cluster_group_counts": 0.0, + "covariance_metadata.group_debias": 0.0, + "covariance_metadata.group_debias_factors": 0.0 + }, + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 1, + "cluster_group_counts": [ + 10 + ], + "group_debias": false, + "group_debias_factors": [ + 1.0 + ] + } + }, + "pooled_cluster_two_way_group_debias": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 2.0816681711721685e-17, + "tvalues": 2.4868995751603507e-14, + "pvalues": 3.0531133177191805e-16, + "conf_int": 1.1102230246251565e-16, + "covariance": 1.734723475976807e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.cluster_dimensions": 0.0, + "covariance_metadata.cluster_group_counts": 0.0, + "covariance_metadata.group_debias": 0.0, + "covariance_metadata.group_debias_factors": 0.0 + }, + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 2, + "cluster_group_counts": [ + 10, + 8, + 74 + ], + "group_debias": true, + "group_debias_factors": [ + 1.0960960960960962, + 1.1274131274131274, + 1.0 + ] + } + }, + "pooled_dk_bartlett": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 5.204170427930421e-18, + "tvalues": 4.263256414560601e-14, + "pvalues": 1.691355389077387e-17, + "conf_int": 1.1102230246251565e-16, + "covariance": 4.336808689942018e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.kernel": 0.0, + "covariance_metadata.bandwidth": 0.0, + "covariance_metadata.n_periods": 0.0, + "covariance_metadata.max_weighted_lag": 0.0, + "covariance_metadata.all_observed_lags_weighted": 0.0, + "covariance_metadata.extra_df": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.rank_deficient_extension": 0.0, + "covariance_metadata.df_scale": 0.0 + }, + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "bartlett", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 2, + "all_observed_lags_weighted": false, + "extra_df": 0, + "design_rank": 3, + "design_columns": 3, + "rank_deficient_extension": false, + "df_scale": 1.0422535211267605 + } + }, + "pooled_dk_qs": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 6.938893903907228e-18, + "tvalues": 4.263256414560601e-14, + "pvalues": 6.938893903907228e-18, + "conf_int": 1.1102230246251565e-16, + "covariance": 4.87890977618477e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.kernel": 0.0, + "covariance_metadata.bandwidth": 0.0, + "covariance_metadata.n_periods": 0.0, + "covariance_metadata.max_weighted_lag": 0.0, + "covariance_metadata.all_observed_lags_weighted": 0.0, + "covariance_metadata.extra_df": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.rank_deficient_extension": 0.0, + "covariance_metadata.df_scale": 0.0 + }, + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "qs", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 7, + "all_observed_lags_weighted": true, + "extra_df": 0, + "design_rank": 3, + "design_columns": 3, + "rank_deficient_extension": false, + "df_scale": 1.0422535211267605 + } + }, + "pooled_legacy_hac": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 3.885780586188048e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 1.0658141036401503e-14, + "pvalues": 8.673617379884035e-18, + "conf_int": 3.885780586188048e-16, + "covariance": 2.0599841277224584e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.kernel": 0.0, + "covariance_metadata.bandwidth": 0.0, + "covariance_metadata.row_order_hac": 0.0 + }, + "covariance_metadata": { + "covariance": "hac", + "kernel": "bartlett", + "bandwidth": 2, + "row_order_hac": true + } + }, + "panel_entity_hc0": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.6653345369377348e-16, + "bse": 1.734723475976807e-17, + "tvalues": 2.1316282072803006e-14, + "pvalues": 2.492586533261947e-65, + "conf_int": 2.220446049250313e-16, + "covariance": 9.75781955236954e-19, + "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": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 5.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0 + }, + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 2, + "design_columns": 2 + } + }, + "panel_entity_hc2": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.6653345369377348e-16, + "bse": 2.0816681711721685e-17, + "tvalues": 2.1316282072803006e-14, + "pvalues": 4.861730685829017e-63, + "conf_int": 2.220446049250313e-16, + "covariance": 1.1926223897340549e-18, + "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": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 5.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 2.168404344971009e-19, + "covariance_metadata.leverage_max": 0.0 + }, + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0005744684754546325, + "leverage_max": 0.19529948562793317 + } + }, + "panel_entity_hc3": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.6653345369377348e-16, + "bse": 1.734723475976807e-17, + "tvalues": 1.7763568394002505e-14, + "pvalues": 3.2235219139320714e-58, + "conf_int": 2.220446049250313e-16, + "covariance": 9.75781955236954e-19, + "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": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 5.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 2.168404344971009e-19, + "covariance_metadata.leverage_max": 0.0 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0005744684754546325, + "leverage_max": 0.19529948562793317 + } + }, + "panel_two_way_hc3": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 3.3306690738754696e-16, + "bse": 2.0816681711721685e-17, + "tvalues": 1.0658141036401503e-14, + "pvalues": 4.3905613070810385e-55, + "conf_int": 4.440892098500626e-16, + "covariance": 8.673617379884035e-19, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 3.410605131648481e-13, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 7.589415207398531e-19, + "covariance_metadata.leverage_max": 2.7755575615628914e-17 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.00046885308084601725, + "leverage_max": 0.15430313435907284 + } + }, + "panel_two_way_cluster_group_debias": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 6.661338147750939e-16, + "bse": 4.5102810375396984e-17, + "tvalues": 3.197442310920451e-14, + "pvalues": 8.599429237094365e-59, + "conf_int": 6.661338147750939e-16, + "covariance": 2.3852447794681098e-18, + "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": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 3.410605131648481e-13, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.cluster_dimensions": 0.0, + "covariance_metadata.cluster_group_counts": 0.0, + "covariance_metadata.group_debias": 0.0, + "covariance_metadata.group_debias_factors": 0.0 + }, + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 2, + "cluster_group_counts": [ + 10, + 8, + 74 + ], + "group_debias": true, + "group_debias_factors": [ + 1.0960960960960962, + 1.1274131274131274, + 1.0 + ] + } + }, + "panel_two_way_dk": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 3.3306690738754696e-16, + "bse": 5.551115123125783e-17, + "tvalues": 1.2789769243681803e-13, + "pvalues": 9.820702847405993e-67, + "conf_int": 4.440892098500626e-16, + "covariance": 2.3852447794681098e-18, + "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": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 3.979039320256561e-13, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.kernel": 0.0, + "covariance_metadata.bandwidth": 0.0, + "covariance_metadata.n_periods": 0.0, + "covariance_metadata.max_weighted_lag": 0.0, + "covariance_metadata.all_observed_lags_weighted": 0.0, + "covariance_metadata.extra_df": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.rank_deficient_extension": 0.0, + "covariance_metadata.df_scale": 0.0 + }, + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "bartlett", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 2, + "all_observed_lags_weighted": false, + "extra_df": 17, + "design_rank": 2, + "design_columns": 2, + "rank_deficient_extension": false, + "df_scale": 1.3454545454545455 + } + }, + "random_effects_explicit_constant_robust": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 6.938893903907228e-18, + "tvalues": 3.552713678800501e-15, + "pvalues": 4.5102810375396984e-17, + "conf_int": 1.1102230246251565e-16, + "covariance": 3.2526065174565133e-19, + "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.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.hc_equivalent": 0.0, + "covariance_metadata.hc1_correction": 0.0 + }, + "covariance_metadata": { + "covariance": "robust", + "hc_equivalent": "hc1", + "hc1_correction": 1.0422535211267605 + } + }, + "random_effects_explicit_constant_hc0": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 6.938893903907228e-18, + "tvalues": 1.7763568394002505e-15, + "pvalues": 3.469446951953614e-17, + "conf_int": 1.1102230246251565e-16, + "covariance": 3.2526065174565133e-19, + "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.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0 + }, + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 3, + "design_columns": 3 + } + }, + "random_effects_explicit_constant_hc2": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 6.938893903907228e-18, + "tvalues": 7.105427357601002e-15, + "pvalues": 6.938893903907228e-17, + "conf_int": 2.220446049250313e-16, + "covariance": 4.336808689942018e-19, + "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.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 0.0, + "covariance_metadata.leverage_max": 0.0 + }, + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.01377346563636502, + "leverage_max": 0.23398280044939523 + } + }, + "random_effects_explicit_constant_hc3": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 3.469446951953614e-18, + "tvalues": 3.552713678800501e-15, + "pvalues": 7.112366251504909e-17, + "conf_int": 1.1102230246251565e-16, + "covariance": 3.2526065174565133e-19, + "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.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 0.0, + "covariance_metadata.leverage_max": 0.0 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.01377346563636502, + "leverage_max": 0.23398280044939523 + } + }, + "random_effects_cluster_two_way": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 2.7755575615628914e-17, + "tvalues": 3.552713678800501e-15, + "pvalues": 1.3877787807814457e-16, + "conf_int": 1.6653345369377348e-16, + "covariance": 5.204170427930421e-18, + "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.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.cluster_dimensions": 0.0, + "covariance_metadata.cluster_group_counts": 0.0, + "covariance_metadata.group_debias": 0.0, + "covariance_metadata.group_debias_factors": 0.0 + }, + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 2, + "cluster_group_counts": [ + 10, + 8, + 74 + ], + "group_debias": true, + "group_debias_factors": [ + 1.0960960960960962, + 1.1274131274131274, + 1.0 + ] + } + }, + "random_effects_dk": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 2.0816681711721685e-17, + "tvalues": 8.526512829121202e-14, + "pvalues": 8.673617379884035e-19, + "conf_int": 1.1102230246251565e-16, + "covariance": 1.3010426069826053e-18, + "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.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.kernel": 0.0, + "covariance_metadata.bandwidth": 0.0, + "covariance_metadata.n_periods": 0.0, + "covariance_metadata.max_weighted_lag": 0.0, + "covariance_metadata.all_observed_lags_weighted": 0.0, + "covariance_metadata.extra_df": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.rank_deficient_extension": 0.0, + "covariance_metadata.df_scale": 0.0 + }, + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "parzen", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 2, + "all_observed_lags_weighted": false, + "extra_df": 0, + "design_rank": 3, + "design_columns": 3, + "rank_deficient_extension": false, + "df_scale": 1.0422535211267605 + } + }, + "between_hc0": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 0.0, + "tvalues": 8.881784197001252e-16, + "pvalues": 9.71445146547012e-17, + "conf_int": 2.220446049250313e-16, + "covariance": 6.938893903907228e-18, + "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": 3.552713678800501e-15, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0 + }, + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 3, + "design_columns": 3 + } + }, + "first_difference_hc0": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 0.0, + "bse": 1.0408340855860843e-17, + "tvalues": 5.329070518200751e-15, + "pvalues": 2.895444548483232e-56, + "conf_int": 0.0, + "covariance": 4.336808689942018e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0 + }, + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 2, + "design_columns": 2 + } + }, + "between_hc2": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 5.551115123125783e-17, + "tvalues": 4.440892098500626e-16, + "pvalues": 2.220446049250313e-16, + "conf_int": 4.440892098500626e-16, + "covariance": 2.7755575615628914e-17, + "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": 3.552713678800501e-15, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 0.0, + "covariance_metadata.leverage_max": 1.1102230246251565e-16 + }, + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.12370974688631299, + "leverage_max": 0.49672782581248376 + } + }, + "first_difference_hc2": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 0.0, + "bse": 1.0408340855860843e-17, + "tvalues": 5.329070518200751e-15, + "pvalues": 2.251230041459491e-52, + "conf_int": 0.0, + "covariance": 4.336808689942018e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 0.0, + "covariance_metadata.leverage_max": 0.0 + }, + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0006345976206143434, + "leverage_max": 0.20961579624221388 + } + }, + "between_hc3": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 8.326672684688674e-17, + "tvalues": 8.881784197001252e-16, + "pvalues": 2.498001805406602e-16, + "conf_int": 2.220446049250313e-16, + "covariance": 2.7755575615628914e-17, + "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": 3.552713678800501e-15, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 0.0, + "covariance_metadata.leverage_max": 1.1102230246251565e-16 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.12370974688631299, + "leverage_max": 0.49672782581248376 + } + }, + "first_difference_hc3": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 0.0, + "bse": 1.0408340855860843e-17, + "tvalues": 3.552713678800501e-15, + "pvalues": 7.64410707086368e-49, + "conf_int": 0.0, + "covariance": 6.505213034913027e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 0.0, + "covariance_metadata.leverage_max": 0.0 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0006345976206143434, + "leverage_max": 0.20961579624221388 + } + } + }, + "public_primitives": { + "cluster_group_debias": { + "status": "success", + "executed_backend": "cupy", + "max_abs_difference": 8.673617379884035e-19 + }, + "driscoll_kraay_qs": { + "status": "success", + "executed_backend": "cupy", + "max_abs_difference": 4.336808689942018e-19 + } + } + }, + "torch": { + "status": "success", + "requested_backend": "torch", + "cases": { + "pooled_hc0": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 6.938893903907228e-18, + "tvalues": 1.0658141036401503e-14, + "pvalues": 1.8214596497756474e-17, + "conf_int": 2.220446049250313e-16, + "covariance": 8.673617379884035e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0 + }, + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 3, + "design_columns": 3 + } + }, + "pooled_hc2": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 1.4210854715202004e-14, + "pvalues": 1.1275702593849246e-17, + "conf_int": 2.220446049250313e-16, + "covariance": 8.673617379884035e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 1.734723475976807e-18, + "covariance_metadata.leverage_max": 0.0 + }, + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.014035716007961321, + "leverage_max": 0.23145706236692962 + } + }, + "pooled_hc3": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 1.4210854715202004e-14, + "pvalues": 1.0408340855860843e-17, + "conf_int": 2.220446049250313e-16, + "covariance": 1.3010426069826053e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 1.734723475976807e-18, + "covariance_metadata.leverage_max": 0.0 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.014035716007961321, + "leverage_max": 0.23145706236692962 + } + }, + "pooled_cluster_one_way": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 1.7763568394002505e-15, + "pvalues": 1.2027843929050015e-56, + "conf_int": 2.220446049250313e-16, + "covariance": 1.734723475976807e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.cluster_dimensions": 0.0, + "covariance_metadata.cluster_group_counts": 0.0, + "covariance_metadata.group_debias": 0.0, + "covariance_metadata.group_debias_factors": 0.0 + }, + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 1, + "cluster_group_counts": [ + 10 + ], + "group_debias": false, + "group_debias_factors": [ + 1.0 + ] + } + }, + "pooled_cluster_two_way_group_debias": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 3.552713678800501e-15, + "pvalues": 2.7755575615628914e-17, + "conf_int": 2.220446049250313e-16, + "covariance": 2.6020852139652106e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.cluster_dimensions": 0.0, + "covariance_metadata.cluster_group_counts": 0.0, + "covariance_metadata.group_debias": 0.0, + "covariance_metadata.group_debias_factors": 0.0 + }, + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 2, + "cluster_group_counts": [ + 10, + 8, + 74 + ], + "group_debias": true, + "group_debias_factors": [ + 1.0960960960960962, + 1.1274131274131274, + 1.0 + ] + } + }, + "pooled_dk_bartlett": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 3.8163916471489756e-17, + "tvalues": 2.7000623958883807e-13, + "pvalues": 5.919157109996828e-61, + "conf_int": 2.220446049250313e-16, + "covariance": 1.463672932855431e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.kernel": 0.0, + "covariance_metadata.bandwidth": 0.0, + "covariance_metadata.n_periods": 0.0, + "covariance_metadata.max_weighted_lag": 0.0, + "covariance_metadata.all_observed_lags_weighted": 0.0, + "covariance_metadata.extra_df": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.rank_deficient_extension": 0.0, + "covariance_metadata.df_scale": 0.0 + }, + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "bartlett", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 2, + "all_observed_lags_weighted": false, + "extra_df": 0, + "design_rank": 3, + "design_columns": 3, + "rank_deficient_extension": false, + "df_scale": 1.0422535211267605 + } + }, + "pooled_dk_qs": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 4.336808689942018e-17, + "tvalues": 3.126388037344441e-13, + "pvalues": 5.204170427930421e-18, + "conf_int": 2.220446049250313e-16, + "covariance": 1.734723475976807e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.kernel": 0.0, + "covariance_metadata.bandwidth": 0.0, + "covariance_metadata.n_periods": 0.0, + "covariance_metadata.max_weighted_lag": 0.0, + "covariance_metadata.all_observed_lags_weighted": 0.0, + "covariance_metadata.extra_df": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.rank_deficient_extension": 0.0, + "covariance_metadata.df_scale": 0.0 + }, + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "qs", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 7, + "all_observed_lags_weighted": true, + "extra_df": 0, + "design_rank": 3, + "design_columns": 3, + "rank_deficient_extension": false, + "df_scale": 1.0422535211267605 + } + }, + "pooled_legacy_hac": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 3.885780586188048e-16, + "bse": 1.0408340855860843e-17, + "tvalues": 1.7763568394002505e-14, + "pvalues": 6.678685382510707e-17, + "conf_int": 3.885780586188048e-16, + "covariance": 1.9244588561617704e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.kernel": 0.0, + "covariance_metadata.bandwidth": 0.0, + "covariance_metadata.row_order_hac": 0.0 + }, + "covariance_metadata": { + "covariance": "hac", + "kernel": "bartlett", + "bandwidth": 2, + "row_order_hac": true + } + }, + "panel_entity_hc0": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 1.734723475976807e-17, + "tvalues": 2.1316282072803006e-14, + "pvalues": 2.492586533261947e-65, + "conf_int": 2.7755575615628914e-16, + "covariance": 8.673617379884035e-19, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 5.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0 + }, + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 2, + "design_columns": 2 + } + }, + "panel_entity_hc2": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 1.0408340855860843e-17, + "tvalues": 1.0658141036401503e-14, + "pvalues": 8.234556349122897e-62, + "conf_int": 2.7755575615628914e-16, + "covariance": 6.505213034913027e-19, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 5.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 3.2526065174565133e-19, + "covariance_metadata.leverage_max": 2.7755575615628914e-17 + }, + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0005744684754546327, + "leverage_max": 0.1952994856279332 + } + }, + "panel_entity_hc3": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 2.42861286636753e-17, + "tvalues": 1.4210854715202004e-14, + "pvalues": 6.098554972303919e-58, + "conf_int": 2.7755575615628914e-16, + "covariance": 1.0842021724855044e-18, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 5.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 1.0842021724855044e-19, + "covariance_metadata.leverage_max": 2.7755575615628914e-17 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0005744684754546324, + "leverage_max": 0.1952994856279332 + } + }, + "panel_two_way_hc3": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 3.3306690738754696e-16, + "bse": 6.938893903907228e-18, + "tvalues": 1.4210854715202004e-14, + "pvalues": 1.2234945877497233e-55, + "conf_int": 3.3306690738754696e-16, + "covariance": 6.454391058077769e-19, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 5.421010862427522e-19, + "covariance_metadata.leverage_max": 8.326672684688674e-17 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.00046885308084601747, + "leverage_max": 0.15430313435907278 + } + }, + "panel_two_way_cluster_group_debias": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 0.0, + "bse": 2.7755575615628914e-17, + "tvalues": 1.5987211554602254e-14, + "pvalues": 4.675040227493183e-59, + "conf_int": 1.1102230246251565e-16, + "covariance": 2.168404344971009e-18, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 1.1368683772161603e-13, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.cluster_dimensions": 0.0, + "covariance_metadata.cluster_group_counts": 0.0, + "covariance_metadata.group_debias": 0.0, + "covariance_metadata.group_debias_factors": 0.0 + }, + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 2, + "cluster_group_counts": [ + 10, + 8, + 74 + ], + "group_debias": true, + "group_debias_factors": [ + 1.0960960960960962, + 1.1274131274131274, + 1.0 + ] + } + }, + "panel_two_way_dk": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 5.551115123125783e-17, + "bse": 1.0408340855860843e-17, + "tvalues": 1.4210854715202004e-14, + "pvalues": 2.2400127769385756e-67, + "conf_int": 5.551115123125783e-17, + "covariance": 5.421010862427522e-19, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 2.2737367544323206e-13, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.kernel": 0.0, + "covariance_metadata.bandwidth": 0.0, + "covariance_metadata.n_periods": 0.0, + "covariance_metadata.max_weighted_lag": 0.0, + "covariance_metadata.all_observed_lags_weighted": 0.0, + "covariance_metadata.extra_df": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.rank_deficient_extension": 0.0, + "covariance_metadata.df_scale": 0.0 + }, + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "bartlett", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 2, + "all_observed_lags_weighted": false, + "extra_df": 17, + "design_rank": 2, + "design_columns": 2, + "rank_deficient_extension": false, + "df_scale": 1.3454545454545455 + } + }, + "random_effects_explicit_constant_robust": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 4.440892098500626e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 2.1316282072803006e-14, + "pvalues": 2.42861286636753e-17, + "conf_int": 4.440892098500626e-16, + "covariance": 6.505213034913027e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.hc_equivalent": 0.0, + "covariance_metadata.hc1_correction": 0.0 + }, + "covariance_metadata": { + "covariance": "robust", + "hc_equivalent": "hc1", + "hc1_correction": 1.0422535211267605 + } + }, + "random_effects_explicit_constant_hc0": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 4.440892098500626e-16, + "bse": 6.938893903907228e-18, + "tvalues": 1.7763568394002505e-14, + "pvalues": 2.949029909160572e-17, + "conf_int": 4.440892098500626e-16, + "covariance": 6.505213034913027e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0 + }, + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 3, + "design_columns": 3 + } + }, + "random_effects_explicit_constant_hc2": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 4.440892098500626e-16, + "bse": 2.7755575615628914e-17, + "tvalues": 2.842170943040401e-14, + "pvalues": 1.0408340855860843e-17, + "conf_int": 5.551115123125783e-16, + "covariance": 1.951563910473908e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 3.469446951953614e-18, + "covariance_metadata.leverage_max": 0.0 + }, + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.013773465636365017, + "leverage_max": 0.23398280044939523 + } + }, + "random_effects_explicit_constant_hc3": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 4.440892098500626e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 1.7763568394002505e-14, + "pvalues": 3.469446951953614e-18, + "conf_int": 4.440892098500626e-16, + "covariance": 1.3010426069826053e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 3.469446951953614e-18, + "covariance_metadata.leverage_max": 0.0 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.013773465636365017, + "leverage_max": 0.23398280044939523 + } + }, + "random_effects_cluster_two_way": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 4.440892098500626e-16, + "bse": 5.551115123125783e-17, + "tvalues": 1.7763568394002505e-14, + "pvalues": 1.942890293094024e-16, + "conf_int": 4.440892098500626e-16, + "covariance": 7.806255641895632e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.cluster_dimensions": 0.0, + "covariance_metadata.cluster_group_counts": 0.0, + "covariance_metadata.group_debias": 0.0, + "covariance_metadata.group_debias_factors": 0.0 + }, + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 2, + "cluster_group_counts": [ + 10, + 8, + 74 + ], + "group_debias": true, + "group_debias_factors": [ + 1.0960960960960962, + 1.1274131274131274, + 1.0 + ] + } + }, + "random_effects_dk": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 4.440892098500626e-16, + "bse": 3.469446951953614e-17, + "tvalues": 1.5631940186722204e-13, + "pvalues": 3.209238430557093e-17, + "conf_int": 5.551115123125783e-16, + "covariance": 2.168404344971009e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.kernel": 0.0, + "covariance_metadata.bandwidth": 0.0, + "covariance_metadata.n_periods": 0.0, + "covariance_metadata.max_weighted_lag": 0.0, + "covariance_metadata.all_observed_lags_weighted": 0.0, + "covariance_metadata.extra_df": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.rank_deficient_extension": 0.0, + "covariance_metadata.df_scale": 0.0 + }, + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "parzen", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 2, + "all_observed_lags_weighted": false, + "extra_df": 0, + "design_rank": 3, + "design_columns": 3, + "rank_deficient_extension": false, + "df_scale": 1.0422535211267605 + } + }, + "between_hc0": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 5.551115123125783e-17, + "tvalues": 4.440892098500626e-16, + "pvalues": 3.3306690738754696e-16, + "conf_int": 2.220446049250313e-16, + "covariance": 3.469446951953614e-17, + "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": 5.329070518200751e-15, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0 + }, + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 3, + "design_columns": 3 + } + }, + "first_difference_hc0": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 0.0, + "bse": 1.0408340855860843e-17, + "tvalues": 7.105427357601002e-15, + "pvalues": 2.895444548483232e-56, + "conf_int": 0.0, + "covariance": 4.336808689942018e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0 + }, + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 2, + "design_columns": 2 + } + }, + "between_hc2": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 5.551115123125783e-17, + "tvalues": 4.440892098500626e-16, + "pvalues": 1.1102230246251565e-16, + "conf_int": 3.3306690738754696e-16, + "covariance": 2.7755575615628914e-17, + "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": 5.329070518200751e-15, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 1.3877787807814457e-17, + "covariance_metadata.leverage_max": 5.551115123125783e-17 + }, + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.12370974688631298, + "leverage_max": 0.4967278258124837 + } + }, + "first_difference_hc2": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 0.0, + "bse": 1.0408340855860843e-17, + "tvalues": 5.329070518200751e-15, + "pvalues": 2.251230041459491e-52, + "conf_int": 0.0, + "covariance": 4.336808689942018e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 1.0842021724855044e-19, + "covariance_metadata.leverage_max": 0.0 + }, + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0006345976206143433, + "leverage_max": 0.20961579624221388 + } + }, + "between_hc3": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 1.1102230246251565e-16, + "tvalues": 4.440892098500626e-16, + "pvalues": 1.6653345369377348e-16, + "conf_int": 4.440892098500626e-16, + "covariance": 5.551115123125783e-17, + "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": 5.329070518200751e-15, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 1.3877787807814457e-17, + "covariance_metadata.leverage_max": 5.551115123125783e-17 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.12370974688631298, + "leverage_max": 0.4967278258124837 + } + }, + "first_difference_hc3": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 0.0, + "bse": 1.0408340855860843e-17, + "tvalues": 3.552713678800501e-15, + "pvalues": 7.64410707086368e-49, + "conf_int": 0.0, + "covariance": 6.505213034913027e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 1.0842021724855044e-19, + "covariance_metadata.leverage_max": 0.0 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0006345976206143433, + "leverage_max": 0.20961579624221388 + } + } + }, + "public_primitives": { + "cluster_group_debias": { + "status": "success", + "executed_backend": "torch", + "max_abs_difference": 8.673617379884035e-19 + }, + "driscoll_kraay_qs": { + "status": "success", + "executed_backend": "torch", + "max_abs_difference": 8.673617379884035e-19 + } + } + } + } +} diff --git a/results/pr126_p100/panel_stage_c_gpu_validation_aad53587.json b/results/pr126_p100/panel_stage_c_gpu_validation_aad53587.json new file mode 100644 index 000000000..4fc52f290 --- /dev/null +++ b/results/pr126_p100/panel_stage_c_gpu_validation_aad53587.json @@ -0,0 +1,1874 @@ +{ + "schema_version": 1, + "generated_at": "2026-08-10T11:28:48.313222Z", + "git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "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 + }, + "dataset": { + "nobs": 74, + "n_entities": 10, + "n_times": 8, + "n_features": 2, + "unbalanced": true + }, + "case_count_per_backend": 26, + "public_primitive_count_per_backend": 6, + "backends": { + "cupy": { + "status": "success", + "requested_backend": "cupy", + "cases": { + "pooled_hc0": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 3.122502256758253e-17, + "tvalues": 1.4210854715202004e-14, + "pvalues": 6.071532165918825e-18, + "conf_int": 2.220446049250313e-16, + "covariance": 2.3852447794681098e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0 + }, + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 3, + "design_columns": 3 + } + }, + "pooled_hc2": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 2.7755575615628914e-17, + "tvalues": 1.0658141036401503e-14, + "pvalues": 3.642919299551295e-17, + "conf_int": 1.3877787807814457e-16, + "covariance": 2.168404344971009e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 0.0, + "covariance_metadata.leverage_max": 1.6653345369377348e-16 + }, + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.014035716007961326, + "leverage_max": 0.23145706236692953 + } + }, + "pooled_hc3": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 3.469446951953614e-17, + "tvalues": 1.7763568394002505e-14, + "pvalues": 2.2551405187698492e-17, + "conf_int": 2.220446049250313e-16, + "covariance": 2.3852447794681098e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 0.0, + "covariance_metadata.leverage_max": 1.6653345369377348e-16 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.014035716007961326, + "leverage_max": 0.23145706236692953 + } + }, + "pooled_cluster_one_way": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 4.163336342344337e-17, + "tvalues": 1.9539925233402755e-14, + "pvalues": 4.996003610813204e-16, + "conf_int": 2.220446049250313e-16, + "covariance": 4.336808689942018e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.cluster_dimensions": 0.0, + "covariance_metadata.cluster_group_counts": 0.0, + "covariance_metadata.group_debias": 0.0, + "covariance_metadata.group_debias_factors": 0.0 + }, + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 1, + "cluster_group_counts": [ + 10 + ], + "group_debias": false, + "group_debias_factors": [ + 1.0 + ] + } + }, + "pooled_cluster_two_way_group_debias": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 2.949029909160572e-17, + "tvalues": 4.263256414560601e-14, + "pvalues": 4.163336342344337e-16, + "conf_int": 2.220446049250313e-16, + "covariance": 3.0357660829594124e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.cluster_dimensions": 0.0, + "covariance_metadata.cluster_group_counts": 0.0, + "covariance_metadata.group_debias": 0.0, + "covariance_metadata.group_debias_factors": 0.0 + }, + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 2, + "cluster_group_counts": [ + 10, + 8, + 74 + ], + "group_debias": true, + "group_debias_factors": [ + 1.0960960960960962, + 1.1274131274131274, + 1.0 + ] + } + }, + "pooled_dk_bartlett": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 1.734723475976807e-17, + "tvalues": 1.4210854715202004e-14, + "pvalues": 5.637851296924623e-18, + "conf_int": 1.1102230246251565e-16, + "covariance": 7.589415207398531e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.kernel": 0.0, + "covariance_metadata.bandwidth": 0.0, + "covariance_metadata.n_periods": 0.0, + "covariance_metadata.max_weighted_lag": 0.0, + "covariance_metadata.all_observed_lags_weighted": 0.0, + "covariance_metadata.extra_df": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.rank_deficient_extension": 0.0, + "covariance_metadata.df_scale": 0.0 + }, + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "bartlett", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 2, + "all_observed_lags_weighted": false, + "extra_df": 0, + "design_rank": 3, + "design_columns": 3, + "rank_deficient_extension": false, + "df_scale": 1.0422535211267605 + } + }, + "pooled_dk_qs": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 1.734723475976807e-17, + "tvalues": 1.4210854715202004e-14, + "pvalues": 1.214306433183765e-17, + "conf_int": 1.1102230246251565e-16, + "covariance": 8.673617379884035e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.kernel": 0.0, + "covariance_metadata.bandwidth": 0.0, + "covariance_metadata.n_periods": 0.0, + "covariance_metadata.max_weighted_lag": 0.0, + "covariance_metadata.all_observed_lags_weighted": 0.0, + "covariance_metadata.extra_df": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.rank_deficient_extension": 0.0, + "covariance_metadata.df_scale": 0.0 + }, + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "qs", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 7, + "all_observed_lags_weighted": true, + "extra_df": 0, + "design_rank": 3, + "design_columns": 3, + "rank_deficient_extension": false, + "df_scale": 1.0422535211267605 + } + }, + "pooled_legacy_hac": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 3.885780586188048e-16, + "bse": 2.7755575615628914e-17, + "tvalues": 7.105427357601002e-15, + "pvalues": 6.071532165918825e-18, + "conf_int": 4.440892098500626e-16, + "covariance": 1.870248747537495e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.kernel": 0.0, + "covariance_metadata.bandwidth": 0.0, + "covariance_metadata.row_order_hac": 0.0 + }, + "covariance_metadata": { + "covariance": "hac", + "kernel": "bartlett", + "bandwidth": 2, + "row_order_hac": true + } + }, + "panel_entity_hc0": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.6653345369377348e-16, + "bse": 2.0816681711721685e-17, + "tvalues": 2.4868995751603507e-14, + "pvalues": 4.443628968523531e-65, + "conf_int": 2.220446049250313e-16, + "covariance": 1.0842021724855044e-18, + "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": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 5.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0 + }, + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 2, + "design_columns": 2 + } + }, + "panel_entity_hc2": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.6653345369377348e-16, + "bse": 2.7755575615628914e-17, + "tvalues": 3.197442310920451e-14, + "pvalues": 3.533870492261967e-61, + "conf_int": 2.220446049250313e-16, + "covariance": 1.4094628242311558e-18, + "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": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 5.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 0.0, + "covariance_metadata.leverage_max": 8.326672684688674e-17 + }, + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0005744684754546323, + "leverage_max": 0.19529948562793312 + } + }, + "panel_entity_hc3": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.6653345369377348e-16, + "bse": 3.469446951953614e-17, + "tvalues": 3.552713678800501e-14, + "pvalues": 1.4785884300198073e-57, + "conf_int": 2.220446049250313e-16, + "covariance": 1.951563910473908e-18, + "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": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 5.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 0.0, + "covariance_metadata.leverage_max": 8.326672684688674e-17 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0005744684754546323, + "leverage_max": 0.19529948562793312 + } + }, + "panel_two_way_hc3": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 3.3306690738754696e-16, + "bse": 1.734723475976807e-17, + "tvalues": 1.0658141036401503e-14, + "pvalues": 4.307720527702151e-55, + "conf_int": 3.3306690738754696e-16, + "covariance": 8.673617379884035e-19, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 2.2737367544323206e-13, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 3.2526065174565133e-19, + "covariance_metadata.leverage_max": 2.7755575615628914e-17 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0004688530808460156, + "leverage_max": 0.15430313435907284 + } + }, + "panel_two_way_cluster_group_debias": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 5.551115123125783e-17, + "bse": 6.938893903907228e-18, + "tvalues": 3.552713678800501e-15, + "pvalues": 2.7225691840642495e-61, + "conf_int": 5.551115123125783e-17, + "covariance": 4.336808689942018e-19, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 1.1368683772161603e-13, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.cluster_dimensions": 0.0, + "covariance_metadata.cluster_group_counts": 0.0, + "covariance_metadata.group_debias": 0.0, + "covariance_metadata.group_debias_factors": 0.0 + }, + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 2, + "cluster_group_counts": [ + 10, + 8, + 74 + ], + "group_debias": true, + "group_debias_factors": [ + 1.0960960960960962, + 1.1274131274131274, + 1.0 + ] + } + }, + "panel_two_way_dk": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 1.0408340855860843e-17, + "tvalues": 3.552713678800501e-14, + "pvalues": 2.141486988560941e-67, + "conf_int": 3.3306690738754696e-16, + "covariance": 4.87890977618477e-19, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 1.1368683772161603e-13, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.kernel": 0.0, + "covariance_metadata.bandwidth": 0.0, + "covariance_metadata.n_periods": 0.0, + "covariance_metadata.max_weighted_lag": 0.0, + "covariance_metadata.all_observed_lags_weighted": 0.0, + "covariance_metadata.extra_df": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.rank_deficient_extension": 0.0, + "covariance_metadata.df_scale": 0.0 + }, + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "bartlett", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 2, + "all_observed_lags_weighted": false, + "extra_df": 17, + "design_rank": 2, + "design_columns": 2, + "rank_deficient_extension": false, + "df_scale": 1.3454545454545455 + } + }, + "random_effects_explicit_constant_robust": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 3.552713678800501e-15, + "pvalues": 8.153200337090993e-17, + "conf_int": 1.6653345369377348e-16, + "covariance": 8.673617379884035e-19, + "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.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.hc_equivalent": 0.0, + "covariance_metadata.hc1_correction": 0.0 + }, + "covariance_metadata": { + "covariance": "robust", + "hc_equivalent": "hc1", + "hc1_correction": 1.0422535211267605 + } + }, + "random_effects_explicit_constant_hc0": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 7.105427357601002e-15, + "pvalues": 7.806255641895632e-17, + "conf_int": 1.1102230246251565e-16, + "covariance": 8.673617379884035e-19, + "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.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0 + }, + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 3, + "design_columns": 3 + } + }, + "random_effects_explicit_constant_hc2": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 6.938893903907228e-18, + "tvalues": 3.552713678800501e-15, + "pvalues": 6.765421556309548e-17, + "conf_int": 1.6653345369377348e-16, + "covariance": 8.673617379884035e-19, + "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.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 0.0, + "covariance_metadata.leverage_max": 2.7755575615628914e-17 + }, + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.013773465636365004, + "leverage_max": 0.23398280044939512 + } + }, + "random_effects_explicit_constant_hc3": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 2.6645352591003757e-15, + "pvalues": 8.847089727481716e-17, + "conf_int": 1.6653345369377348e-16, + "covariance": 8.673617379884035e-19, + "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.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 0.0, + "covariance_metadata.leverage_max": 2.7755575615628914e-17 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.013773465636365004, + "leverage_max": 0.23398280044939512 + } + }, + "random_effects_cluster_two_way": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 3.552713678800501e-15, + "pvalues": 1.3877787807814457e-16, + "conf_int": 1.3877787807814457e-16, + "covariance": 2.6020852139652106e-18, + "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.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.cluster_dimensions": 0.0, + "covariance_metadata.cluster_group_counts": 0.0, + "covariance_metadata.group_debias": 0.0, + "covariance_metadata.group_debias_factors": 0.0 + }, + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 2, + "cluster_group_counts": [ + 10, + 8, + 74 + ], + "group_debias": true, + "group_debias_factors": [ + 1.0960960960960962, + 1.1274131274131274, + 1.0 + ] + } + }, + "random_effects_dk": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 2.6020852139652106e-17, + "tvalues": 1.2789769243681803e-13, + "pvalues": 2.3418766925686896e-17, + "conf_int": 2.220446049250313e-16, + "covariance": 8.809142651444724e-19, + "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.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.kernel": 0.0, + "covariance_metadata.bandwidth": 0.0, + "covariance_metadata.n_periods": 0.0, + "covariance_metadata.max_weighted_lag": 0.0, + "covariance_metadata.all_observed_lags_weighted": 0.0, + "covariance_metadata.extra_df": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.rank_deficient_extension": 0.0, + "covariance_metadata.df_scale": 0.0 + }, + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "parzen", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 2, + "all_observed_lags_weighted": false, + "extra_df": 0, + "design_rank": 3, + "design_columns": 3, + "rank_deficient_extension": false, + "df_scale": 1.0422535211267605 + } + }, + "between_hc0": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 1.1102230246251565e-16, + "tvalues": 4.440892098500626e-15, + "pvalues": 1.1102230246251565e-16, + "conf_int": 4.440892098500626e-16, + "covariance": 3.122502256758253e-17, + "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": 3.552713678800501e-15, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0 + }, + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 3, + "design_columns": 3 + } + }, + "first_difference_hc0": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 0.0, + "bse": 1.0408340855860843e-17, + "tvalues": 1.0658141036401503e-14, + "pvalues": 9.956824444577827e-57, + "conf_int": 0.0, + "covariance": 4.336808689942018e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0 + }, + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 2, + "design_columns": 2 + } + }, + "between_hc2": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 1.3877787807814457e-16, + "tvalues": 3.552713678800501e-15, + "pvalues": 2.220446049250313e-16, + "conf_int": 3.3306690738754696e-16, + "covariance": 4.85722573273506e-17, + "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": 3.552713678800501e-15, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 5.551115123125783e-17, + "covariance_metadata.leverage_max": 4.440892098500626e-16 + }, + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.12370974688631295, + "leverage_max": 0.49672782581248387 + } + }, + "first_difference_hc2": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 0.0, + "bse": 1.0408340855860843e-17, + "tvalues": 1.0658141036401503e-14, + "pvalues": 9.20067929987792e-53, + "conf_int": 0.0, + "covariance": 6.505213034913027e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 3.2526065174565133e-19, + "covariance_metadata.leverage_max": 5.551115123125783e-17 + }, + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0006345976206143431, + "leverage_max": 0.20961579624221383 + } + }, + "between_hc3": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 1.942890293094024e-16, + "tvalues": 3.552713678800501e-15, + "pvalues": 2.220446049250313e-16, + "conf_int": 4.440892098500626e-16, + "covariance": 1.1102230246251565e-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": 3.552713678800501e-15, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 5.551115123125783e-17, + "covariance_metadata.leverage_max": 4.440892098500626e-16 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.12370974688631295, + "leverage_max": 0.49672782581248387 + } + }, + "first_difference_hc3": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 0.0, + "bse": 1.0408340855860843e-17, + "tvalues": 7.105427357601002e-15, + "pvalues": 9.621952956331904e-50, + "conf_int": 0.0, + "covariance": 6.505213034913027e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 3.2526065174565133e-19, + "covariance_metadata.leverage_max": 5.551115123125783e-17 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0006345976206143431, + "leverage_max": 0.20961579624221383 + } + } + }, + "public_primitives": { + "cluster_group_debias": { + "status": "success", + "executed_backend": "cupy", + "max_abs_difference": 5.204170427930421e-18 + }, + "driscoll_kraay_qs": { + "status": "success", + "executed_backend": "cupy", + "max_abs_difference": 1.0842021724855044e-18 + }, + "ill_conditioned_hc0": { + "status": "success", + "executed_backend": "cupy", + "max_abs_difference": 30929317.0 + }, + "ill_conditioned_hc2": { + "status": "success", + "executed_backend": "cupy", + "max_abs_difference": 21155431.25 + }, + "ill_conditioned_hc3": { + "status": "success", + "executed_backend": "cupy", + "max_abs_difference": 6772311.25 + }, + "ill_conditioned_dk": { + "status": "success", + "executed_backend": "cupy", + "max_abs_difference": 170369115.25 + } + } + }, + "torch": { + "status": "success", + "requested_backend": "torch", + "cases": { + "pooled_hc0": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 2.0816681711721685e-17, + "tvalues": 7.105427357601002e-15, + "pvalues": 3.122502256758253e-17, + "conf_int": 2.220446049250313e-16, + "covariance": 1.3010426069826053e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0 + }, + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 3, + "design_columns": 3 + } + }, + "pooled_hc2": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 2.0816681711721685e-17, + "tvalues": 1.0658141036401503e-14, + "pvalues": 6.071532165918825e-18, + "conf_int": 2.220446049250313e-16, + "covariance": 1.3010426069826053e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 1.734723475976807e-18, + "covariance_metadata.leverage_max": 0.0 + }, + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.014035716007961324, + "leverage_max": 0.2314570623669297 + } + }, + "pooled_hc3": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 2.7755575615628914e-17, + "tvalues": 1.7763568394002505e-14, + "pvalues": 2.949029909160572e-17, + "conf_int": 3.3306690738754696e-16, + "covariance": 1.5178830414797062e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 1.734723475976807e-18, + "covariance_metadata.leverage_max": 0.0 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.014035716007961324, + "leverage_max": 0.2314570623669297 + } + }, + "pooled_cluster_one_way": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 2.7755575615628914e-17, + "tvalues": 1.7763568394002505e-14, + "pvalues": 2.7755575615628914e-16, + "conf_int": 2.220446049250313e-16, + "covariance": 3.469446951953614e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.cluster_dimensions": 0.0, + "covariance_metadata.cluster_group_counts": 0.0, + "covariance_metadata.group_debias": 0.0, + "covariance_metadata.group_debias_factors": 0.0 + }, + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 1, + "cluster_group_counts": [ + 10 + ], + "group_debias": false, + "group_debias_factors": [ + 1.0 + ] + } + }, + "pooled_cluster_two_way_group_debias": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 2.7755575615628914e-17, + "tvalues": 2.842170943040401e-14, + "pvalues": 1.6653345369377348e-16, + "conf_int": 3.3306690738754696e-16, + "covariance": 4.336808689942018e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.cluster_dimensions": 0.0, + "covariance_metadata.cluster_group_counts": 0.0, + "covariance_metadata.group_debias": 0.0, + "covariance_metadata.group_debias_factors": 0.0 + }, + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 2, + "cluster_group_counts": [ + 10, + 8, + 74 + ], + "group_debias": true, + "group_debias_factors": [ + 1.0960960960960962, + 1.1274131274131274, + 1.0 + ] + } + }, + "pooled_dk_bartlett": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 3.2959746043559335e-17, + "tvalues": 2.2737367544323206e-13, + "pvalues": 1.0842021724855044e-17, + "conf_int": 2.220446049250313e-16, + "covariance": 1.1384122811097797e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.kernel": 0.0, + "covariance_metadata.bandwidth": 0.0, + "covariance_metadata.n_periods": 0.0, + "covariance_metadata.max_weighted_lag": 0.0, + "covariance_metadata.all_observed_lags_weighted": 0.0, + "covariance_metadata.extra_df": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.rank_deficient_extension": 0.0, + "covariance_metadata.df_scale": 0.0 + }, + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "bartlett", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 2, + "all_observed_lags_weighted": false, + "extra_df": 0, + "design_rank": 3, + "design_columns": 3, + "rank_deficient_extension": false, + "df_scale": 1.0422535211267605 + } + }, + "pooled_dk_qs": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 3.8163916471489756e-17, + "tvalues": 2.7000623958883807e-13, + "pvalues": 5.637851296924623e-18, + "conf_int": 2.220446049250313e-16, + "covariance": 1.1926223897340549e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.kernel": 0.0, + "covariance_metadata.bandwidth": 0.0, + "covariance_metadata.n_periods": 0.0, + "covariance_metadata.max_weighted_lag": 0.0, + "covariance_metadata.all_observed_lags_weighted": 0.0, + "covariance_metadata.extra_df": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.rank_deficient_extension": 0.0, + "covariance_metadata.df_scale": 0.0 + }, + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "qs", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 7, + "all_observed_lags_weighted": true, + "extra_df": 0, + "design_rank": 3, + "design_columns": 3, + "rank_deficient_extension": false, + "df_scale": 1.0422535211267605 + } + }, + "pooled_legacy_hac": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 3.885780586188048e-16, + "bse": 3.469446951953614e-17, + "tvalues": 1.0658141036401503e-14, + "pvalues": 4.2934406030425976e-17, + "conf_int": 4.440892098500626e-16, + "covariance": 2.0599841277224584e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.kernel": 0.0, + "covariance_metadata.bandwidth": 0.0, + "covariance_metadata.row_order_hac": 0.0 + }, + "covariance_metadata": { + "covariance": "hac", + "kernel": "bartlett", + "bandwidth": 2, + "row_order_hac": true + } + }, + "panel_entity_hc0": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 2.42861286636753e-17, + "tvalues": 2.842170943040401e-14, + "pvalues": 2.12908433049458e-65, + "conf_int": 2.7755575615628914e-16, + "covariance": 1.1926223897340549e-18, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 5.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0 + }, + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 2, + "design_columns": 2 + } + }, + "panel_entity_hc2": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 3.469446951953614e-17, + "tvalues": 3.907985046680551e-14, + "pvalues": 8.234556349122897e-62, + "conf_int": 2.7755575615628914e-16, + "covariance": 1.8431436932253575e-18, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 5.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 1.0842021724855044e-19, + "covariance_metadata.leverage_max": 5.551115123125783e-17 + }, + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0005744684754546322, + "leverage_max": 0.19529948562793314 + } + }, + "panel_entity_hc3": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 3.8163916471489756e-17, + "tvalues": 3.907985046680551e-14, + "pvalues": 3.4848885556022394e-59, + "conf_int": 2.7755575615628914e-16, + "covariance": 2.0599841277224584e-18, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 5.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 1.0842021724855044e-19, + "covariance_metadata.leverage_max": 5.551115123125783e-17 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0005744684754546322, + "leverage_max": 0.19529948562793314 + } + }, + "panel_two_way_hc3": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 6.661338147750939e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 1.4210854715202004e-14, + "pvalues": 3.2499074987102026e-55, + "conf_int": 6.661338147750939e-16, + "covariance": 1.0842021724855044e-18, + "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": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 2.2737367544323206e-13, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 9.75781955236954e-19, + "covariance_metadata.leverage_max": 2.7755575615628914e-17 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.000468853080846015, + "leverage_max": 0.15430313435907278 + } + }, + "panel_two_way_cluster_group_debias": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 4.440892098500626e-16, + "bse": 4.163336342344337e-17, + "tvalues": 2.6645352591003757e-14, + "pvalues": 7.164246338637639e-59, + "conf_int": 5.551115123125783e-16, + "covariance": 1.951563910473908e-18, + "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": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 1.1368683772161603e-13, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.cluster_dimensions": 0.0, + "covariance_metadata.cluster_group_counts": 0.0, + "covariance_metadata.group_debias": 0.0, + "covariance_metadata.group_debias_factors": 0.0 + }, + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 2, + "cluster_group_counts": [ + 10, + 8, + 74 + ], + "group_debias": true, + "group_debias_factors": [ + 1.0960960960960962, + 1.1274131274131274, + 1.0 + ] + } + }, + "panel_two_way_dk": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 6.661338147750939e-16, + "bse": 5.898059818321144e-17, + "tvalues": 2.3447910280083306e-13, + "pvalues": 9.180285222951368e-67, + "conf_int": 7.771561172376096e-16, + "covariance": 2.439454888092385e-18, + "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": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 1.1368683772161603e-13, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.kernel": 0.0, + "covariance_metadata.bandwidth": 0.0, + "covariance_metadata.n_periods": 0.0, + "covariance_metadata.max_weighted_lag": 0.0, + "covariance_metadata.all_observed_lags_weighted": 0.0, + "covariance_metadata.extra_df": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.rank_deficient_extension": 0.0, + "covariance_metadata.df_scale": 0.0 + }, + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "bartlett", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 2, + "all_observed_lags_weighted": false, + "extra_df": 17, + "design_rank": 2, + "design_columns": 2, + "rank_deficient_extension": false, + "df_scale": 1.3454545454545455 + } + }, + "random_effects_explicit_constant_robust": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 4.440892098500626e-16, + "bse": 2.0816681711721685e-17, + "tvalues": 2.4868995751603507e-14, + "pvalues": 5.204170427930421e-17, + "conf_int": 4.440892098500626e-16, + "covariance": 1.734723475976807e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.hc_equivalent": 0.0, + "covariance_metadata.hc1_correction": 0.0 + }, + "covariance_metadata": { + "covariance": "robust", + "hc_equivalent": "hc1", + "hc1_correction": 1.0422535211267605 + } + }, + "random_effects_explicit_constant_hc0": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 4.440892098500626e-16, + "bse": 2.0816681711721685e-17, + "tvalues": 2.4868995751603507e-14, + "pvalues": 3.469446951953614e-17, + "conf_int": 4.440892098500626e-16, + "covariance": 1.5178830414797062e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0 + }, + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 3, + "design_columns": 3 + } + }, + "random_effects_explicit_constant_hc2": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 4.440892098500626e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 2.1316282072803006e-14, + "pvalues": 2.7755575615628914e-17, + "conf_int": 4.440892098500626e-16, + "covariance": 1.3010426069826053e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 1.734723475976807e-18, + "covariance_metadata.leverage_max": 0.0 + }, + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.013773465636365006, + "leverage_max": 0.23398280044939515 + } + }, + "random_effects_explicit_constant_hc3": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 4.440892098500626e-16, + "bse": 3.469446951953614e-17, + "tvalues": 2.842170943040401e-14, + "pvalues": 5.724587470723463e-17, + "conf_int": 5.551115123125783e-16, + "covariance": 2.3852447794681098e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 1.734723475976807e-18, + "covariance_metadata.leverage_max": 0.0 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.013773465636365006, + "leverage_max": 0.23398280044939515 + } + }, + "random_effects_cluster_two_way": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 4.440892098500626e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 2.1316282072803006e-14, + "pvalues": 7.812547416892606e-96, + "conf_int": 4.440892098500626e-16, + "covariance": 1.734723475976807e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.cluster_dimensions": 0.0, + "covariance_metadata.cluster_group_counts": 0.0, + "covariance_metadata.group_debias": 0.0, + "covariance_metadata.group_debias_factors": 0.0 + }, + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 2, + "cluster_group_counts": [ + 10, + 8, + 74 + ], + "group_debias": true, + "group_debias_factors": [ + 1.0960960960960962, + 1.1274131274131274, + 1.0 + ] + } + }, + "random_effects_dk": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 4.440892098500626e-16, + "bse": 1.734723475976807e-17, + "tvalues": 1.2789769243681803e-13, + "pvalues": 8.673617379884035e-19, + "conf_int": 4.440892098500626e-16, + "covariance": 1.0299920638612292e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.kernel": 0.0, + "covariance_metadata.bandwidth": 0.0, + "covariance_metadata.n_periods": 0.0, + "covariance_metadata.max_weighted_lag": 0.0, + "covariance_metadata.all_observed_lags_weighted": 0.0, + "covariance_metadata.extra_df": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.rank_deficient_extension": 0.0, + "covariance_metadata.df_scale": 0.0 + }, + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "parzen", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 2, + "all_observed_lags_weighted": false, + "extra_df": 0, + "design_rank": 3, + "design_columns": 3, + "rank_deficient_extension": false, + "df_scale": 1.0422535211267605 + } + }, + "between_hc0": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 8.326672684688674e-17, + "tvalues": 2.6645352591003757e-15, + "pvalues": 2.220446049250313e-16, + "conf_int": 4.440892098500626e-16, + "covariance": 2.0816681711721685e-17, + "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": 5.329070518200751e-15, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0 + }, + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 3, + "design_columns": 3 + } + }, + "first_difference_hc0": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 0.0, + "bse": 1.734723475976807e-17, + "tvalues": 1.7763568394002505e-14, + "pvalues": 1.9236584826924361e-56, + "conf_int": 5.551115123125783e-17, + "covariance": 9.75781955236954e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0 + }, + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 2, + "design_columns": 2 + } + }, + "between_hc2": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 1.1102230246251565e-16, + "tvalues": 2.6645352591003757e-15, + "pvalues": 3.191891195797325e-16, + "conf_int": 4.440892098500626e-16, + "covariance": 3.469446951953614e-17, + "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": 5.329070518200751e-15, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 8.326672684688674e-17, + "covariance_metadata.leverage_max": 1.1102230246251565e-16 + }, + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.12370974688631298, + "leverage_max": 0.49672782581248354 + } + }, + "first_difference_hc2": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 0.0, + "bse": 1.0408340855860843e-17, + "tvalues": 1.0658141036401503e-14, + "pvalues": 9.20067929987792e-53, + "conf_int": 0.0, + "covariance": 6.505213034913027e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 3.2526065174565133e-19, + "covariance_metadata.leverage_max": 2.7755575615628914e-17 + }, + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0006345976206143431, + "leverage_max": 0.20961579624221385 + } + }, + "between_hc3": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 1.6653345369377348e-16, + "tvalues": 2.6645352591003757e-15, + "pvalues": 2.7755575615628914e-16, + "conf_int": 4.440892098500626e-16, + "covariance": 6.938893903907228e-17, + "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": 5.329070518200751e-15, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 8.326672684688674e-17, + "covariance_metadata.leverage_max": 1.1102230246251565e-16 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.12370974688631298, + "leverage_max": 0.49672782581248354 + } + }, + "first_difference_hc3": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 0.0, + "bse": 1.3877787807814457e-17, + "tvalues": 1.0658141036401503e-14, + "pvalues": 1.641077531996608e-48, + "conf_int": 1.1102230246251565e-16, + "covariance": 8.673617379884035e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 3.2526065174565133e-19, + "covariance_metadata.leverage_max": 2.7755575615628914e-17 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0006345976206143431, + "leverage_max": 0.20961579624221385 + } + } + }, + "public_primitives": { + "cluster_group_debias": { + "status": "success", + "executed_backend": "torch", + "max_abs_difference": 1.8973538018496328e-18 + }, + "driscoll_kraay_qs": { + "status": "success", + "executed_backend": "torch", + "max_abs_difference": 8.673617379884035e-19 + }, + "ill_conditioned_hc0": { + "status": "success", + "executed_backend": "torch", + "max_abs_difference": 30929317.125 + }, + "ill_conditioned_hc2": { + "status": "success", + "executed_backend": "torch", + "max_abs_difference": 24439511.5 + }, + "ill_conditioned_hc3": { + "status": "success", + "executed_backend": "torch", + "max_abs_difference": 14989546.25 + }, + "ill_conditioned_dk": { + "status": "success", + "executed_backend": "torch", + "max_abs_difference": 170369115.0 + } + } + } + } +} diff --git a/results/pr126_p100/panel_stage_c_gpu_validation_c151550a.json b/results/pr126_p100/panel_stage_c_gpu_validation_c151550a.json new file mode 100644 index 000000000..ecaf21a96 --- /dev/null +++ b/results/pr126_p100/panel_stage_c_gpu_validation_c151550a.json @@ -0,0 +1,1834 @@ +{ + "schema_version": 1, + "generated_at": "2026-08-10T06:13:47.252297Z", + "git_sha": "c151550ab17bd9533a51599f86b6a4ea12a292e9", + "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 + }, + "dataset": { + "nobs": 74, + "n_entities": 10, + "n_times": 8, + "n_features": 2, + "unbalanced": true + }, + "case_count_per_backend": 26, + "public_primitive_count_per_backend": 2, + "backends": { + "cupy": { + "status": "success", + "requested_backend": "cupy", + "cases": { + "pooled_hc0": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 3.469446951953614e-18, + "tvalues": 3.552713678800501e-15, + "pvalues": 3.729655473350135e-17, + "conf_int": 1.1102230246251565e-16, + "covariance": 3.2526065174565133e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0 + }, + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 3, + "design_columns": 3 + } + }, + "pooled_hc2": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 6.938893903907228e-18, + "tvalues": 1.7763568394002505e-15, + "pvalues": 3.9898639947466563e-17, + "conf_int": 1.1102230246251565e-16, + "covariance": 2.303929616531697e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 0.0, + "covariance_metadata.leverage_max": 0.0 + }, + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.014035716007961323, + "leverage_max": 0.23145706236692962 + } + }, + "pooled_hc3": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 6.938893903907228e-18, + "tvalues": 3.552713678800501e-15, + "pvalues": 3.9898639947466563e-17, + "conf_int": 1.1102230246251565e-16, + "covariance": 4.336808689942018e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 0.0, + "covariance_metadata.leverage_max": 0.0 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.014035716007961323, + "leverage_max": 0.23145706236692962 + } + }, + "pooled_cluster_one_way": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 0.0, + "tvalues": 1.7763568394002505e-15, + "pvalues": 3.0531133177191805e-16, + "conf_int": 1.1102230246251565e-16, + "covariance": 6.505213034913027e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.cluster_dimensions": 0.0, + "covariance_metadata.cluster_group_counts": 0.0, + "covariance_metadata.group_debias": 0.0, + "covariance_metadata.group_debias_factors": 0.0 + }, + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 1, + "cluster_group_counts": [ + 10 + ], + "group_debias": false, + "group_debias_factors": [ + 1.0 + ] + } + }, + "pooled_cluster_two_way_group_debias": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 2.0816681711721685e-17, + "tvalues": 2.4868995751603507e-14, + "pvalues": 3.0531133177191805e-16, + "conf_int": 1.1102230246251565e-16, + "covariance": 1.734723475976807e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.cluster_dimensions": 0.0, + "covariance_metadata.cluster_group_counts": 0.0, + "covariance_metadata.group_debias": 0.0, + "covariance_metadata.group_debias_factors": 0.0 + }, + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 2, + "cluster_group_counts": [ + 10, + 8, + 74 + ], + "group_debias": true, + "group_debias_factors": [ + 1.0960960960960962, + 1.1274131274131274, + 1.0 + ] + } + }, + "pooled_dk_bartlett": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 3.469446951953614e-18, + "tvalues": 2.842170943040401e-14, + "pvalues": 1.691355389077387e-17, + "conf_int": 1.1102230246251565e-16, + "covariance": 4.336808689942018e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.kernel": 0.0, + "covariance_metadata.bandwidth": 0.0, + "covariance_metadata.n_periods": 0.0, + "covariance_metadata.max_weighted_lag": 0.0, + "covariance_metadata.all_observed_lags_weighted": 0.0, + "covariance_metadata.extra_df": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.rank_deficient_extension": 0.0, + "covariance_metadata.df_scale": 0.0 + }, + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "bartlett", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 2, + "all_observed_lags_weighted": false, + "extra_df": 0, + "design_rank": 3, + "design_columns": 3, + "rank_deficient_extension": false, + "df_scale": 1.0422535211267605 + } + }, + "pooled_dk_qs": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 6.938893903907228e-18, + "tvalues": 4.263256414560601e-14, + "pvalues": 6.938893903907228e-18, + "conf_int": 1.1102230246251565e-16, + "covariance": 4.336808689942018e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.kernel": 0.0, + "covariance_metadata.bandwidth": 0.0, + "covariance_metadata.n_periods": 0.0, + "covariance_metadata.max_weighted_lag": 0.0, + "covariance_metadata.all_observed_lags_weighted": 0.0, + "covariance_metadata.extra_df": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.rank_deficient_extension": 0.0, + "covariance_metadata.df_scale": 0.0 + }, + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "qs", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 7, + "all_observed_lags_weighted": true, + "extra_df": 0, + "design_rank": 3, + "design_columns": 3, + "rank_deficient_extension": false, + "df_scale": 1.0422535211267605 + } + }, + "pooled_legacy_hac": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 3.885780586188048e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 1.0658141036401503e-14, + "pvalues": 8.673617379884035e-18, + "conf_int": 3.885780586188048e-16, + "covariance": 2.0599841277224584e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.kernel": 0.0, + "covariance_metadata.bandwidth": 0.0, + "covariance_metadata.row_order_hac": 0.0 + }, + "covariance_metadata": { + "covariance": "hac", + "kernel": "bartlett", + "bandwidth": 2, + "row_order_hac": true + } + }, + "panel_entity_hc0": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.6653345369377348e-16, + "bse": 1.734723475976807e-17, + "tvalues": 2.1316282072803006e-14, + "pvalues": 2.492586533261947e-65, + "conf_int": 2.220446049250313e-16, + "covariance": 9.75781955236954e-19, + "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": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 5.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0 + }, + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 2, + "design_columns": 2 + } + }, + "panel_entity_hc2": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.6653345369377348e-16, + "bse": 2.0816681711721685e-17, + "tvalues": 2.1316282072803006e-14, + "pvalues": 4.861730685829017e-63, + "conf_int": 2.220446049250313e-16, + "covariance": 1.1926223897340549e-18, + "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": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 5.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 0.0, + "covariance_metadata.leverage_max": 0.0 + }, + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0005744684754546323, + "leverage_max": 0.19529948562793317 + } + }, + "panel_entity_hc3": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.6653345369377348e-16, + "bse": 1.734723475976807e-17, + "tvalues": 1.7763568394002505e-14, + "pvalues": 3.2235219139320714e-58, + "conf_int": 2.220446049250313e-16, + "covariance": 9.75781955236954e-19, + "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": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 5.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 0.0, + "covariance_metadata.leverage_max": 0.0 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0005744684754546323, + "leverage_max": 0.19529948562793317 + } + }, + "panel_two_way_hc3": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 3.3306690738754696e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 3.552713678800501e-15, + "pvalues": 1.2234945877497233e-55, + "conf_int": 4.440892098500626e-16, + "covariance": 1.0842021724855044e-18, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 3.410605131648481e-13, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 5.421010862427522e-19, + "covariance_metadata.leverage_max": 2.7755575615628914e-17 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.00046885308084601747, + "leverage_max": 0.15430313435907284 + } + }, + "panel_two_way_cluster_group_debias": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 2.7755575615628914e-17, + "tvalues": 1.0658141036401503e-14, + "pvalues": 1.40406782206742e-59, + "conf_int": 1.6653345369377348e-16, + "covariance": 2.3852447794681098e-18, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 3.410605131648481e-13, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.cluster_dimensions": 0.0, + "covariance_metadata.cluster_group_counts": 0.0, + "covariance_metadata.group_debias": 0.0, + "covariance_metadata.group_debias_factors": 0.0 + }, + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 2, + "cluster_group_counts": [ + 10, + 8, + 74 + ], + "group_debias": true, + "group_debias_factors": [ + 1.0960960960960962, + 1.1274131274131274, + 1.0 + ] + } + }, + "panel_two_way_dk": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 1.5987211554602254e-14, + "pvalues": 3.3237964490925565e-67, + "conf_int": 1.1102230246251565e-16, + "covariance": 5.963111948670274e-19, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 3.410605131648481e-13, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.kernel": 0.0, + "covariance_metadata.bandwidth": 0.0, + "covariance_metadata.n_periods": 0.0, + "covariance_metadata.max_weighted_lag": 0.0, + "covariance_metadata.all_observed_lags_weighted": 0.0, + "covariance_metadata.extra_df": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.rank_deficient_extension": 0.0, + "covariance_metadata.df_scale": 0.0 + }, + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "bartlett", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 2, + "all_observed_lags_weighted": false, + "extra_df": 17, + "design_rank": 2, + "design_columns": 2, + "rank_deficient_extension": false, + "df_scale": 1.3454545454545455 + } + }, + "random_effects_explicit_constant_robust": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 6.938893903907228e-18, + "tvalues": 3.552713678800501e-15, + "pvalues": 4.5102810375396984e-17, + "conf_int": 1.1102230246251565e-16, + "covariance": 3.2526065174565133e-19, + "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.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.hc_equivalent": 0.0, + "covariance_metadata.hc1_correction": 0.0 + }, + "covariance_metadata": { + "covariance": "robust", + "hc_equivalent": "hc1", + "hc1_correction": 1.0422535211267605 + } + }, + "random_effects_explicit_constant_hc0": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 6.938893903907228e-18, + "tvalues": 1.7763568394002505e-15, + "pvalues": 3.469446951953614e-17, + "conf_int": 1.1102230246251565e-16, + "covariance": 3.2526065174565133e-19, + "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.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0 + }, + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 3, + "design_columns": 3 + } + }, + "random_effects_explicit_constant_hc2": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 6.938893903907228e-18, + "tvalues": 7.105427357601002e-15, + "pvalues": 6.938893903907228e-17, + "conf_int": 2.220446049250313e-16, + "covariance": 4.336808689942018e-19, + "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.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 0.0, + "covariance_metadata.leverage_max": 0.0 + }, + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.01377346563636502, + "leverage_max": 0.23398280044939523 + } + }, + "random_effects_explicit_constant_hc3": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 3.469446951953614e-18, + "tvalues": 3.552713678800501e-15, + "pvalues": 7.112366251504909e-17, + "conf_int": 1.1102230246251565e-16, + "covariance": 3.2526065174565133e-19, + "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.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 0.0, + "covariance_metadata.leverage_max": 0.0 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.01377346563636502, + "leverage_max": 0.23398280044939523 + } + }, + "random_effects_cluster_two_way": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 2.7755575615628914e-17, + "tvalues": 3.552713678800501e-15, + "pvalues": 1.3877787807814457e-16, + "conf_int": 1.6653345369377348e-16, + "covariance": 5.204170427930421e-18, + "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.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.cluster_dimensions": 0.0, + "covariance_metadata.cluster_group_counts": 0.0, + "covariance_metadata.group_debias": 0.0, + "covariance_metadata.group_debias_factors": 0.0 + }, + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 2, + "cluster_group_counts": [ + 10, + 8, + 74 + ], + "group_debias": true, + "group_debias_factors": [ + 1.0960960960960962, + 1.1274131274131274, + 1.0 + ] + } + }, + "random_effects_dk": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 2.0816681711721685e-17, + "tvalues": 8.526512829121202e-14, + "pvalues": 8.673617379884035e-19, + "conf_int": 1.1102230246251565e-16, + "covariance": 1.3010426069826053e-18, + "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.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.kernel": 0.0, + "covariance_metadata.bandwidth": 0.0, + "covariance_metadata.n_periods": 0.0, + "covariance_metadata.max_weighted_lag": 0.0, + "covariance_metadata.all_observed_lags_weighted": 0.0, + "covariance_metadata.extra_df": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.rank_deficient_extension": 0.0, + "covariance_metadata.df_scale": 0.0 + }, + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "parzen", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 2, + "all_observed_lags_weighted": false, + "extra_df": 0, + "design_rank": 3, + "design_columns": 3, + "rank_deficient_extension": false, + "df_scale": 1.0422535211267605 + } + }, + "between_hc0": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 0.0, + "tvalues": 8.881784197001252e-16, + "pvalues": 9.71445146547012e-17, + "conf_int": 2.220446049250313e-16, + "covariance": 6.938893903907228e-18, + "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": 3.552713678800501e-15, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0 + }, + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 3, + "design_columns": 3 + } + }, + "first_difference_hc0": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 0.0, + "bse": 1.0408340855860843e-17, + "tvalues": 5.329070518200751e-15, + "pvalues": 2.895444548483232e-56, + "conf_int": 0.0, + "covariance": 4.336808689942018e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0 + }, + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 2, + "design_columns": 2 + } + }, + "between_hc2": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 5.551115123125783e-17, + "tvalues": 4.440892098500626e-16, + "pvalues": 2.220446049250313e-16, + "conf_int": 4.440892098500626e-16, + "covariance": 2.7755575615628914e-17, + "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": 3.552713678800501e-15, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 0.0, + "covariance_metadata.leverage_max": 1.1102230246251565e-16 + }, + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.12370974688631299, + "leverage_max": 0.49672782581248376 + } + }, + "first_difference_hc2": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 0.0, + "bse": 1.0408340855860843e-17, + "tvalues": 5.329070518200751e-15, + "pvalues": 2.251230041459491e-52, + "conf_int": 0.0, + "covariance": 4.336808689942018e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 0.0, + "covariance_metadata.leverage_max": 0.0 + }, + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0006345976206143434, + "leverage_max": 0.20961579624221388 + } + }, + "between_hc3": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 8.326672684688674e-17, + "tvalues": 8.881784197001252e-16, + "pvalues": 2.498001805406602e-16, + "conf_int": 2.220446049250313e-16, + "covariance": 2.7755575615628914e-17, + "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": 3.552713678800501e-15, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 0.0, + "covariance_metadata.leverage_max": 1.1102230246251565e-16 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.12370974688631299, + "leverage_max": 0.49672782581248376 + } + }, + "first_difference_hc3": { + "status": "success", + "executed_backend": "cupy", + "max_abs_differences": { + "coef": 0.0, + "bse": 1.0408340855860843e-17, + "tvalues": 3.552713678800501e-15, + "pvalues": 7.64410707086368e-49, + "conf_int": 0.0, + "covariance": 6.505213034913027e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 0.0, + "covariance_metadata.leverage_max": 0.0 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0006345976206143434, + "leverage_max": 0.20961579624221388 + } + } + }, + "public_primitives": { + "cluster_group_debias": { + "status": "success", + "executed_backend": "cupy", + "max_abs_difference": 8.673617379884035e-19 + }, + "driscoll_kraay_qs": { + "status": "success", + "executed_backend": "cupy", + "max_abs_difference": 4.336808689942018e-19 + } + } + }, + "torch": { + "status": "success", + "requested_backend": "torch", + "cases": { + "pooled_hc0": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 6.938893903907228e-18, + "tvalues": 1.0658141036401503e-14, + "pvalues": 1.8214596497756474e-17, + "conf_int": 2.220446049250313e-16, + "covariance": 8.673617379884035e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0 + }, + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 3, + "design_columns": 3 + } + }, + "pooled_hc2": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 1.4210854715202004e-14, + "pvalues": 1.1275702593849246e-17, + "conf_int": 2.220446049250313e-16, + "covariance": 8.673617379884035e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 1.734723475976807e-18, + "covariance_metadata.leverage_max": 0.0 + }, + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.014035716007961321, + "leverage_max": 0.23145706236692962 + } + }, + "pooled_hc3": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 1.4210854715202004e-14, + "pvalues": 1.0408340855860843e-17, + "conf_int": 2.220446049250313e-16, + "covariance": 1.3010426069826053e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 1.734723475976807e-18, + "covariance_metadata.leverage_max": 0.0 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.014035716007961321, + "leverage_max": 0.23145706236692962 + } + }, + "pooled_cluster_one_way": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 5.329070518200751e-15, + "pvalues": 2.309983271142056e-56, + "conf_int": 2.220446049250313e-16, + "covariance": 1.734723475976807e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.cluster_dimensions": 0.0, + "covariance_metadata.cluster_group_counts": 0.0, + "covariance_metadata.group_debias": 0.0, + "covariance_metadata.group_debias_factors": 0.0 + }, + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 1, + "cluster_group_counts": [ + 10 + ], + "group_debias": false, + "group_debias_factors": [ + 1.0 + ] + } + }, + "pooled_cluster_two_way_group_debias": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 5.204170427930421e-18, + "tvalues": 3.552713678800501e-15, + "pvalues": 5.551115123125783e-17, + "conf_int": 2.220446049250313e-16, + "covariance": 2.6020852139652106e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.cluster_dimensions": 0.0, + "covariance_metadata.cluster_group_counts": 0.0, + "covariance_metadata.group_debias": 0.0, + "covariance_metadata.group_debias_factors": 0.0 + }, + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 2, + "cluster_group_counts": [ + 10, + 8, + 74 + ], + "group_debias": true, + "group_debias_factors": [ + 1.0960960960960962, + 1.1274131274131274, + 1.0 + ] + } + }, + "pooled_dk_bartlett": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 3.8163916471489756e-17, + "tvalues": 2.7000623958883807e-13, + "pvalues": 5.919157109996828e-61, + "conf_int": 2.220446049250313e-16, + "covariance": 1.599198204416119e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.kernel": 0.0, + "covariance_metadata.bandwidth": 0.0, + "covariance_metadata.n_periods": 0.0, + "covariance_metadata.max_weighted_lag": 0.0, + "covariance_metadata.all_observed_lags_weighted": 0.0, + "covariance_metadata.extra_df": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.rank_deficient_extension": 0.0, + "covariance_metadata.df_scale": 0.0 + }, + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "bartlett", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 2, + "all_observed_lags_weighted": false, + "extra_df": 0, + "design_rank": 3, + "design_columns": 3, + "rank_deficient_extension": false, + "df_scale": 1.0422535211267605 + } + }, + "pooled_dk_qs": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 4.163336342344337e-17, + "tvalues": 2.984279490192421e-13, + "pvalues": 5.204170427930421e-18, + "conf_int": 2.220446049250313e-16, + "covariance": 1.6805133673525319e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.kernel": 0.0, + "covariance_metadata.bandwidth": 0.0, + "covariance_metadata.n_periods": 0.0, + "covariance_metadata.max_weighted_lag": 0.0, + "covariance_metadata.all_observed_lags_weighted": 0.0, + "covariance_metadata.extra_df": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.rank_deficient_extension": 0.0, + "covariance_metadata.df_scale": 0.0 + }, + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "qs", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 7, + "all_observed_lags_weighted": true, + "extra_df": 0, + "design_rank": 3, + "design_columns": 3, + "rank_deficient_extension": false, + "df_scale": 1.0422535211267605 + } + }, + "pooled_legacy_hac": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 3.885780586188048e-16, + "bse": 1.0408340855860843e-17, + "tvalues": 1.7763568394002505e-14, + "pvalues": 6.678685382510707e-17, + "conf_int": 3.885780586188048e-16, + "covariance": 1.9244588561617704e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.kernel": 0.0, + "covariance_metadata.bandwidth": 0.0, + "covariance_metadata.row_order_hac": 0.0 + }, + "covariance_metadata": { + "covariance": "hac", + "kernel": "bartlett", + "bandwidth": 2, + "row_order_hac": true + } + }, + "panel_entity_hc0": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 1.734723475976807e-17, + "tvalues": 2.1316282072803006e-14, + "pvalues": 2.492586533261947e-65, + "conf_int": 2.7755575615628914e-16, + "covariance": 8.673617379884035e-19, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 5.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0 + }, + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 2, + "design_columns": 2 + } + }, + "panel_entity_hc2": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 1.0408340855860843e-17, + "tvalues": 1.0658141036401503e-14, + "pvalues": 8.234556349122897e-62, + "conf_int": 2.7755575615628914e-16, + "covariance": 6.505213034913027e-19, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 5.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 3.2526065174565133e-19, + "covariance_metadata.leverage_max": 2.7755575615628914e-17 + }, + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0005744684754546327, + "leverage_max": 0.1952994856279332 + } + }, + "panel_entity_hc3": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 2.42861286636753e-17, + "tvalues": 1.4210854715202004e-14, + "pvalues": 6.098554972303919e-58, + "conf_int": 2.7755575615628914e-16, + "covariance": 1.0842021724855044e-18, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 5.684341886080802e-14, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 3.2526065174565133e-19, + "covariance_metadata.leverage_max": 2.7755575615628914e-17 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0005744684754546327, + "leverage_max": 0.1952994856279332 + } + }, + "panel_two_way_hc3": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 3.552713678800501e-15, + "pvalues": 1.2234945877497233e-55, + "conf_int": 3.3306690738754696e-16, + "covariance": 1.0842021724855044e-18, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 3.410605131648481e-13, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 6.505213034913027e-19, + "covariance_metadata.leverage_max": 5.551115123125783e-17 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.00046885308084601736, + "leverage_max": 0.1543031343590728 + } + }, + "panel_two_way_cluster_group_debias": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 4.163336342344337e-17, + "tvalues": 1.7763568394002505e-14, + "pvalues": 1.40406782206742e-59, + "conf_int": 1.6653345369377348e-16, + "covariance": 3.469446951953614e-18, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 1.7053025658242404e-13, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.cluster_dimensions": 0.0, + "covariance_metadata.cluster_group_counts": 0.0, + "covariance_metadata.group_debias": 0.0, + "covariance_metadata.group_debias_factors": 0.0 + }, + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 2, + "cluster_group_counts": [ + 10, + 8, + 74 + ], + "group_debias": true, + "group_debias_factors": [ + 1.0960960960960962, + 1.1274131274131274, + 1.0 + ] + } + }, + "panel_two_way_dk": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 1.1102230246251565e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 1.5987211554602254e-14, + "pvalues": 3.3237964490925565e-67, + "conf_int": 1.1102230246251565e-16, + "covariance": 7.047314121155779e-19, + "nobs": 0.0, + "df_resid": 0.0, + "fit_statistics.rsquared_within": 0.0, + "fit_statistics.rsquared_between": 1.1102230246251565e-16, + "fit_statistics.rsquared_overall": 1.1102230246251565e-16, + "fit_statistics.rsquared_adj": 1.1102230246251565e-16, + "fit_statistics.f_statistic": 3.410605131648481e-13, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.kernel": 0.0, + "covariance_metadata.bandwidth": 0.0, + "covariance_metadata.n_periods": 0.0, + "covariance_metadata.max_weighted_lag": 0.0, + "covariance_metadata.all_observed_lags_weighted": 0.0, + "covariance_metadata.extra_df": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.rank_deficient_extension": 0.0, + "covariance_metadata.df_scale": 0.0 + }, + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "bartlett", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 2, + "all_observed_lags_weighted": false, + "extra_df": 17, + "design_rank": 2, + "design_columns": 2, + "rank_deficient_extension": false, + "df_scale": 1.3454545454545455 + } + }, + "random_effects_explicit_constant_robust": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 4.440892098500626e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 2.1316282072803006e-14, + "pvalues": 2.42861286636753e-17, + "conf_int": 4.440892098500626e-16, + "covariance": 6.505213034913027e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.hc_equivalent": 0.0, + "covariance_metadata.hc1_correction": 0.0 + }, + "covariance_metadata": { + "covariance": "robust", + "hc_equivalent": "hc1", + "hc1_correction": 1.0422535211267605 + } + }, + "random_effects_explicit_constant_hc0": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 4.440892098500626e-16, + "bse": 6.938893903907228e-18, + "tvalues": 1.7763568394002505e-14, + "pvalues": 2.949029909160572e-17, + "conf_int": 4.440892098500626e-16, + "covariance": 6.505213034913027e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0 + }, + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 3, + "design_columns": 3 + } + }, + "random_effects_explicit_constant_hc2": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 4.440892098500626e-16, + "bse": 2.7755575615628914e-17, + "tvalues": 2.842170943040401e-14, + "pvalues": 1.0408340855860843e-17, + "conf_int": 5.551115123125783e-16, + "covariance": 1.951563910473908e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 3.469446951953614e-18, + "covariance_metadata.leverage_max": 0.0 + }, + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.013773465636365017, + "leverage_max": 0.23398280044939523 + } + }, + "random_effects_explicit_constant_hc3": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 4.440892098500626e-16, + "bse": 1.3877787807814457e-17, + "tvalues": 1.7763568394002505e-14, + "pvalues": 3.469446951953614e-18, + "conf_int": 4.440892098500626e-16, + "covariance": 1.3010426069826053e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 3.469446951953614e-18, + "covariance_metadata.leverage_max": 0.0 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.013773465636365017, + "leverage_max": 0.23398280044939523 + } + }, + "random_effects_cluster_two_way": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 4.440892098500626e-16, + "bse": 5.551115123125783e-17, + "tvalues": 1.7763568394002505e-14, + "pvalues": 1.942890293094024e-16, + "conf_int": 4.440892098500626e-16, + "covariance": 7.806255641895632e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.cluster_dimensions": 0.0, + "covariance_metadata.cluster_group_counts": 0.0, + "covariance_metadata.group_debias": 0.0, + "covariance_metadata.group_debias_factors": 0.0 + }, + "covariance_metadata": { + "covariance": "clustered", + "cluster_dimensions": 2, + "cluster_group_counts": [ + 10, + 8, + 74 + ], + "group_debias": true, + "group_debias_factors": [ + 1.0960960960960962, + 1.1274131274131274, + 1.0 + ] + } + }, + "random_effects_dk": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 4.440892098500626e-16, + "bse": 4.163336342344337e-17, + "tvalues": 1.5631940186722204e-13, + "pvalues": 3.209238430557093e-17, + "conf_int": 5.551115123125783e-16, + "covariance": 2.6020852139652106e-18, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.kernel": 0.0, + "covariance_metadata.bandwidth": 0.0, + "covariance_metadata.n_periods": 0.0, + "covariance_metadata.max_weighted_lag": 0.0, + "covariance_metadata.all_observed_lags_weighted": 0.0, + "covariance_metadata.extra_df": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.rank_deficient_extension": 0.0, + "covariance_metadata.df_scale": 0.0 + }, + "covariance_metadata": { + "covariance": "driscoll-kraay", + "kernel": "parzen", + "bandwidth": 2, + "n_periods": 8, + "max_weighted_lag": 2, + "all_observed_lags_weighted": false, + "extra_df": 0, + "design_rank": 3, + "design_columns": 3, + "rank_deficient_extension": false, + "df_scale": 1.0422535211267605 + } + }, + "between_hc0": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 5.551115123125783e-17, + "tvalues": 4.440892098500626e-16, + "pvalues": 3.3306690738754696e-16, + "conf_int": 2.220446049250313e-16, + "covariance": 3.469446951953614e-17, + "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": 5.329070518200751e-15, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0 + }, + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 3, + "design_columns": 3 + } + }, + "first_difference_hc0": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 0.0, + "bse": 1.0408340855860843e-17, + "tvalues": 7.105427357601002e-15, + "pvalues": 2.895444548483232e-56, + "conf_int": 0.0, + "covariance": 4.336808689942018e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0 + }, + "covariance_metadata": { + "covariance": "hc0", + "design_rank": 2, + "design_columns": 2 + } + }, + "between_hc2": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 5.551115123125783e-17, + "tvalues": 4.440892098500626e-16, + "pvalues": 1.1102230246251565e-16, + "conf_int": 3.3306690738754696e-16, + "covariance": 2.7755575615628914e-17, + "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": 5.329070518200751e-15, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 1.3877787807814457e-17, + "covariance_metadata.leverage_max": 5.551115123125783e-17 + }, + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.12370974688631298, + "leverage_max": 0.4967278258124837 + } + }, + "first_difference_hc2": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 0.0, + "bse": 1.0408340855860843e-17, + "tvalues": 5.329070518200751e-15, + "pvalues": 2.251230041459491e-52, + "conf_int": 0.0, + "covariance": 4.336808689942018e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 1.0842021724855044e-19, + "covariance_metadata.leverage_max": 0.0 + }, + "covariance_metadata": { + "covariance": "hc2", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0006345976206143433, + "leverage_max": 0.20961579624221388 + } + }, + "between_hc3": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 2.220446049250313e-16, + "bse": 1.1102230246251565e-16, + "tvalues": 4.440892098500626e-16, + "pvalues": 1.6653345369377348e-16, + "conf_int": 4.440892098500626e-16, + "covariance": 5.551115123125783e-17, + "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": 5.329070518200751e-15, + "fit_statistics.f_pvalue": 0.0, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 1.3877787807814457e-17, + "covariance_metadata.leverage_max": 5.551115123125783e-17 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 3, + "design_columns": 3, + "leverage_min": 0.12370974688631298, + "leverage_max": 0.4967278258124837 + } + }, + "first_difference_hc3": { + "status": "success", + "executed_backend": "torch", + "max_abs_differences": { + "coef": 0.0, + "bse": 1.0408340855860843e-17, + "tvalues": 3.552713678800501e-15, + "pvalues": 7.64410707086368e-49, + "conf_int": 0.0, + "covariance": 6.505213034913027e-19, + "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, + "covariance_metadata.covariance": 0.0, + "covariance_metadata.design_rank": 0.0, + "covariance_metadata.design_columns": 0.0, + "covariance_metadata.leverage_min": 1.0842021724855044e-19, + "covariance_metadata.leverage_max": 0.0 + }, + "covariance_metadata": { + "covariance": "hc3", + "design_rank": 2, + "design_columns": 2, + "leverage_min": 0.0006345976206143433, + "leverage_max": 0.20961579624221388 + } + } + }, + "public_primitives": { + "cluster_group_debias": { + "status": "success", + "executed_backend": "torch", + "max_abs_difference": 8.673617379884035e-19 + }, + "driscoll_kraay_qs": { + "status": "success", + "executed_backend": "torch", + "max_abs_difference": 4.336808689942018e-19 + } + } + } + } +} diff --git a/results/pr126_p100/panel_stage_c_performance_9c0b3050.json b/results/pr126_p100/panel_stage_c_performance_9c0b3050.json new file mode 100644 index 000000000..53a06d827 --- /dev/null +++ b/results/pr126_p100/panel_stage_c_performance_9c0b3050.json @@ -0,0 +1,895 @@ +{ + "schema_version": 2, + "git_sha": "9c0b3050dd143c43a06bb6393d69f4f83e861637", + "working_tree_clean": true, + "benchmark": "panel_stage_c_covariance_fit_overhead", + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "high_t_scale": "10000x2x200", + "environment": { + "python": "3.9.16", + "platform": "Linux-3.10.0-1062.el7.x86_64-x86_64-with-glibc2.31", + "gpu_by_backend": { + "cupy": "Tesla P100-SXM2-16GB", + "torch": "Tesla P100-SXM2-16GB" + }, + "packages": { + "statgpu": "0.2.4", + "numpy": "1.24.2", + "cupy": null, + "torch": "2.0.0" + } + }, + "rows": [ + { + "backend": "cupy", + "case": "pooled_nonrobust", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.0061387717723846436, + "samples_seconds": [ + 0.006368696689605713, + 0.0061387717723846436, + 0.006103873252868652 + ] + }, + { + "backend": "cupy", + "case": "pooled_hc3", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.005926936864852905, + "samples_seconds": [ + 0.005913078784942627, + 0.005926936864852905, + 0.00598829984664917 + ] + }, + { + "backend": "cupy", + "case": "pooled_cluster_two_way", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.012396514415740967, + "samples_seconds": [ + 0.012396514415740967, + 0.012268126010894775, + 0.01252281665802002 + ] + }, + { + "backend": "cupy", + "case": "pooled_dk_qs", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.008103370666503906, + "samples_seconds": [ + 0.00798901915550232, + 0.008169829845428467, + 0.008103370666503906 + ] + }, + { + "backend": "cupy", + "case": "panel_entity_nonrobust", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.01721322536468506, + "samples_seconds": [ + 0.017297685146331787, + 0.01718655228614807, + 0.01721322536468506 + ] + }, + { + "backend": "cupy", + "case": "panel_entity_hc3", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.015020877122879028, + "samples_seconds": [ + 0.015020877122879028, + 0.014986693859100342, + 0.015172630548477173 + ] + }, + { + "backend": "cupy", + "case": "panel_entity_dk", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.01695042848587036, + "samples_seconds": [ + 0.017162799835205078, + 0.01695042848587036, + 0.016948193311691284 + ] + }, + { + "backend": "cupy", + "case": "random_effects_nonrobust", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.020707905292510986, + "samples_seconds": [ + 0.020632386207580566, + 0.020707905292510986, + 0.02081400156021118 + ] + }, + { + "backend": "cupy", + "case": "random_effects_hc3", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.018796443939208984, + "samples_seconds": [ + 0.018603593111038208, + 0.018812507390975952, + 0.018796443939208984 + ] + }, + { + "backend": "torch", + "case": "pooled_nonrobust", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.006654202938079834, + "samples_seconds": [ + 0.006912201642990112, + 0.006654202938079834, + 0.006600290536880493 + ] + }, + { + "backend": "torch", + "case": "pooled_hc3", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.006312340497970581, + "samples_seconds": [ + 0.006306767463684082, + 0.006320446729660034, + 0.006312340497970581 + ] + }, + { + "backend": "torch", + "case": "pooled_cluster_two_way", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.01214626431465149, + "samples_seconds": [ + 0.012191802263259888, + 0.01214626431465149, + 0.012088477611541748 + ] + }, + { + "backend": "torch", + "case": "pooled_dk_qs", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.007876366376876831, + "samples_seconds": [ + 0.007921159267425537, + 0.007876366376876831, + 0.007863521575927734 + ] + }, + { + "backend": "torch", + "case": "panel_entity_nonrobust", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.014412164688110352, + "samples_seconds": [ + 0.014437735080718994, + 0.014283567667007446, + 0.014412164688110352 + ] + }, + { + "backend": "torch", + "case": "panel_entity_hc3", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.012234777212142944, + "samples_seconds": [ + 0.01205703616142273, + 0.012234777212142944, + 0.012385666370391846 + ] + }, + { + "backend": "torch", + "case": "panel_entity_dk", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.013910561800003052, + "samples_seconds": [ + 0.014185428619384766, + 0.013910561800003052, + 0.013898283243179321 + ] + }, + { + "backend": "torch", + "case": "random_effects_nonrobust", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.016689777374267578, + "samples_seconds": [ + 0.016887903213500977, + 0.016689777374267578, + 0.01664409041404724 + ] + }, + { + "backend": "torch", + "case": "random_effects_hc3", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.014641731977462769, + "samples_seconds": [ + 0.014782547950744629, + 0.014527589082717896, + 0.014641731977462769 + ] + }, + { + "backend": "cupy", + "case": "pooled_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.0084705650806427, + "samples_seconds": [ + 0.008541315793991089, + 0.0084705650806427, + 0.008441835641860962 + ] + }, + { + "backend": "cupy", + "case": "pooled_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.00738835334777832, + "samples_seconds": [ + 0.0073580145835876465, + 0.00740283727645874, + 0.00738835334777832 + ] + }, + { + "backend": "cupy", + "case": "pooled_cluster_two_way", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.06970715522766113, + "samples_seconds": [ + 0.07080218195915222, + 0.06970715522766113, + 0.06952935457229614 + ] + }, + { + "backend": "cupy", + "case": "pooled_dk_qs", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.011930793523788452, + "samples_seconds": [ + 0.011930793523788452, + 0.011915415525436401, + 0.011934161186218262 + ] + }, + { + "backend": "cupy", + "case": "panel_entity_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.049842000007629395, + "samples_seconds": [ + 0.04979899525642395, + 0.049842000007629395, + 0.05084866285324097 + ] + }, + { + "backend": "cupy", + "case": "panel_entity_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.037675946950912476, + "samples_seconds": [ + 0.03755977749824524, + 0.03786781430244446, + 0.037675946950912476 + ] + }, + { + "backend": "cupy", + "case": "panel_entity_dk", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.051383912563323975, + "samples_seconds": [ + 0.051395565271377563, + 0.051383912563323975, + 0.05128294229507446 + ] + }, + { + "backend": "cupy", + "case": "random_effects_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.0653739869594574, + "samples_seconds": [ + 0.0653739869594574, + 0.06515300273895264, + 0.06714147329330444 + ] + }, + { + "backend": "cupy", + "case": "random_effects_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.056291282176971436, + "samples_seconds": [ + 0.05639159679412842, + 0.056128501892089844, + 0.056291282176971436 + ] + }, + { + "backend": "torch", + "case": "pooled_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.008631318807601929, + "samples_seconds": [ + 0.008824855089187622, + 0.008631318807601929, + 0.00860661268234253 + ] + }, + { + "backend": "torch", + "case": "pooled_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.008852958679199219, + "samples_seconds": [ + 0.008852958679199219, + 0.008851766586303711, + 0.008861631155014038 + ] + }, + { + "backend": "torch", + "case": "pooled_cluster_two_way", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.07910990715026855, + "samples_seconds": [ + 0.07420048117637634, + 0.07910990715026855, + 0.08081644773483276 + ] + }, + { + "backend": "torch", + "case": "pooled_dk_qs", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.014443397521972656, + "samples_seconds": [ + 0.014490187168121338, + 0.014443397521972656, + 0.014416217803955078 + ] + }, + { + "backend": "torch", + "case": "panel_entity_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.05168259143829346, + "samples_seconds": [ + 0.051764458417892456, + 0.05168259143829346, + 0.05139485001564026 + ] + }, + { + "backend": "torch", + "case": "panel_entity_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.04037678241729736, + "samples_seconds": [ + 0.04037678241729736, + 0.03840792179107666, + 0.040383875370025635 + ] + }, + { + "backend": "torch", + "case": "panel_entity_dk", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.054943233728408813, + "samples_seconds": [ + 0.055475205183029175, + 0.054943233728408813, + 0.054397523403167725 + ] + }, + { + "backend": "torch", + "case": "random_effects_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.06473469734191895, + "samples_seconds": [ + 0.06582540273666382, + 0.06436985731124878, + 0.06473469734191895 + ] + }, + { + "backend": "torch", + "case": "random_effects_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.05454641580581665, + "samples_seconds": [ + 0.058052897453308105, + 0.0542619526386261, + 0.05454641580581665 + ] + }, + { + "backend": "cupy", + "case": "pooled_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.012777775526046753, + "samples_seconds": [ + 0.012823611497879028, + 0.012777775526046753, + 0.012725263833999634 + ] + }, + { + "backend": "cupy", + "case": "pooled_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.01102447509765625, + "samples_seconds": [ + 0.011040687561035156, + 0.01102447509765625, + 0.011004894971847534 + ] + }, + { + "backend": "cupy", + "case": "pooled_cluster_two_way", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.07202821969985962, + "samples_seconds": [ + 0.07200169563293457, + 0.07467427849769592, + 0.07202821969985962 + ] + }, + { + "backend": "cupy", + "case": "pooled_dk_qs", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.015592217445373535, + "samples_seconds": [ + 0.01547914743423462, + 0.015816539525985718, + 0.015592217445373535 + ] + }, + { + "backend": "cupy", + "case": "panel_entity_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.12444207072257996, + "samples_seconds": [ + 0.12444207072257996, + 0.12462574243545532, + 0.12427785992622375 + ] + }, + { + "backend": "cupy", + "case": "panel_entity_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.09159401059150696, + "samples_seconds": [ + 0.09207361936569214, + 0.09113430976867676, + 0.09159401059150696 + ] + }, + { + "backend": "cupy", + "case": "panel_entity_dk", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.10452467203140259, + "samples_seconds": [ + 0.10452467203140259, + 0.10730963945388794, + 0.10415557026863098 + ] + }, + { + "backend": "cupy", + "case": "random_effects_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.1929284930229187, + "samples_seconds": [ + 0.18534338474273682, + 0.1929284930229187, + 0.19303572177886963 + ] + }, + { + "backend": "cupy", + "case": "random_effects_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.15861374139785767, + "samples_seconds": [ + 0.15861374139785767, + 0.15921607613563538, + 0.1583806574344635 + ] + }, + { + "backend": "torch", + "case": "pooled_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.01262974739074707, + "samples_seconds": [ + 0.012814879417419434, + 0.01262974739074707, + 0.012571722269058228 + ] + }, + { + "backend": "torch", + "case": "pooled_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.014248013496398926, + "samples_seconds": [ + 0.014229565858840942, + 0.014248013496398926, + 0.014292001724243164 + ] + }, + { + "backend": "torch", + "case": "pooled_cluster_two_way", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.08110934495925903, + "samples_seconds": [ + 0.08157917857170105, + 0.08110934495925903, + 0.08010280132293701 + ] + }, + { + "backend": "torch", + "case": "pooled_dk_qs", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.019062548875808716, + "samples_seconds": [ + 0.019032448530197144, + 0.019075125455856323, + 0.019062548875808716 + ] + }, + { + "backend": "torch", + "case": "panel_entity_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.12556102871894836, + "samples_seconds": [ + 0.12665686011314392, + 0.12556102871894836, + 0.12552589178085327 + ] + }, + { + "backend": "torch", + "case": "panel_entity_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.09175285696983337, + "samples_seconds": [ + 0.09112736582756042, + 0.094672292470932, + 0.09175285696983337 + ] + }, + { + "backend": "torch", + "case": "panel_entity_dk", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.1056717038154602, + "samples_seconds": [ + 0.10569682717323303, + 0.10553708672523499, + 0.1056717038154602 + ] + }, + { + "backend": "torch", + "case": "random_effects_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.18080830574035645, + "samples_seconds": [ + 0.1799287497997284, + 0.18080830574035645, + 0.18207868933677673 + ] + }, + { + "backend": "torch", + "case": "random_effects_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.15586915612220764, + "samples_seconds": [ + 0.15151533484458923, + 0.15586915612220764, + 0.1575460135936737 + ] + }, + { + "backend": "cupy", + "case": "pooled_dk_qs", + "scenario": "high_t_qs", + "n_samples": 10000, + "n_features": 2, + "n_times": 200, + "repeats": 3, + "median_seconds": 0.02357661724090576, + "samples_seconds": [ + 0.023634523153305054, + 0.023575693368911743, + 0.02357661724090576 + ] + }, + { + "backend": "cupy", + "case": "panel_entity_dk_qs", + "scenario": "high_t_qs", + "n_samples": 10000, + "n_features": 2, + "n_times": 200, + "repeats": 3, + "median_seconds": 0.032750725746154785, + "samples_seconds": [ + 0.03374722599983215, + 0.032750725746154785, + 0.031490474939346313 + ] + }, + { + "backend": "torch", + "case": "pooled_dk_qs", + "scenario": "high_t_qs", + "n_samples": 10000, + "n_features": 2, + "n_times": 200, + "repeats": 3, + "median_seconds": 0.01593637466430664, + "samples_seconds": [ + 0.016089022159576416, + 0.015922963619232178, + 0.01593637466430664 + ] + }, + { + "backend": "torch", + "case": "panel_entity_dk_qs", + "scenario": "high_t_qs", + "n_samples": 10000, + "n_features": 2, + "n_times": 200, + "repeats": 3, + "median_seconds": 0.023551732301712036, + "samples_seconds": [ + 0.023463845252990723, + 0.023551732301712036, + 0.023805469274520874 + ] + } + ] +} diff --git a/results/pr126_p100/panel_stage_c_performance_aad53587.json b/results/pr126_p100/panel_stage_c_performance_aad53587.json new file mode 100644 index 000000000..fd7b06e0b --- /dev/null +++ b/results/pr126_p100/panel_stage_c_performance_aad53587.json @@ -0,0 +1,895 @@ +{ + "schema_version": 2, + "git_sha": "aad53587c9611da0e71a676e86ef32d9f6403f5c", + "working_tree_clean": true, + "benchmark": "panel_stage_c_covariance_fit_overhead", + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "high_t_scale": "10000x2x200", + "environment": { + "python": "3.9.16", + "platform": "Linux-3.10.0-1062.el7.x86_64-x86_64-with-glibc2.31", + "gpu_by_backend": { + "cupy": "Tesla P100-SXM2-16GB", + "torch": "Tesla P100-SXM2-16GB" + }, + "packages": { + "statgpu": "0.2.4", + "numpy": "1.24.2", + "cupy": null, + "torch": "2.0.0" + } + }, + "rows": [ + { + "backend": "cupy", + "case": "pooled_nonrobust", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.007405370473861694, + "samples_seconds": [ + 0.007631957530975342, + 0.007405370473861694, + 0.007290899753570557 + ] + }, + { + "backend": "cupy", + "case": "pooled_hc3", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.006349414587020874, + "samples_seconds": [ + 0.006349414587020874, + 0.006302386522293091, + 0.006429195404052734 + ] + }, + { + "backend": "cupy", + "case": "pooled_cluster_two_way", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.016390174627304077, + "samples_seconds": [ + 0.016288161277770996, + 0.016634434461593628, + 0.016390174627304077 + ] + }, + { + "backend": "cupy", + "case": "pooled_dk_qs", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.008806496858596802, + "samples_seconds": [ + 0.008913993835449219, + 0.008806496858596802, + 0.008765608072280884 + ] + }, + { + "backend": "cupy", + "case": "panel_entity_nonrobust", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.018040448427200317, + "samples_seconds": [ + 0.01843234896659851, + 0.018040448427200317, + 0.017939835786819458 + ] + }, + { + "backend": "cupy", + "case": "panel_entity_hc3", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.014901578426361084, + "samples_seconds": [ + 0.014951318502426147, + 0.01469847559928894, + 0.014901578426361084 + ] + }, + { + "backend": "cupy", + "case": "panel_entity_dk", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.01694503426551819, + "samples_seconds": [ + 0.01694503426551819, + 0.017024904489517212, + 0.016873806715011597 + ] + }, + { + "backend": "cupy", + "case": "random_effects_nonrobust", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.021593332290649414, + "samples_seconds": [ + 0.021790802478790283, + 0.021518290042877197, + 0.021593332290649414 + ] + }, + { + "backend": "cupy", + "case": "random_effects_hc3", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.01827523112297058, + "samples_seconds": [ + 0.01863768696784973, + 0.018218427896499634, + 0.01827523112297058 + ] + }, + { + "backend": "torch", + "case": "pooled_nonrobust", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.00887441635131836, + "samples_seconds": [ + 0.009030520915985107, + 0.00887441635131836, + 0.00886031985282898 + ] + }, + { + "backend": "torch", + "case": "pooled_hc3", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.00745275616645813, + "samples_seconds": [ + 0.007542520761489868, + 0.00745275616645813, + 0.007409721612930298 + ] + }, + { + "backend": "torch", + "case": "pooled_cluster_two_way", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.01841592788696289, + "samples_seconds": [ + 0.01841592788696289, + 0.018323630094528198, + 0.01857084035873413 + ] + }, + { + "backend": "torch", + "case": "pooled_dk_qs", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.009230375289916992, + "samples_seconds": [ + 0.009230375289916992, + 0.009288370609283447, + 0.009204655885696411 + ] + }, + { + "backend": "torch", + "case": "panel_entity_nonrobust", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.01623395085334778, + "samples_seconds": [ + 0.016425639390945435, + 0.01623395085334778, + 0.01617678999900818 + ] + }, + { + "backend": "torch", + "case": "panel_entity_hc3", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.01336824893951416, + "samples_seconds": [ + 0.01339772343635559, + 0.01336824893951416, + 0.013209879398345947 + ] + }, + { + "backend": "torch", + "case": "panel_entity_dk", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.01526758074760437, + "samples_seconds": [ + 0.015288025140762329, + 0.015251725912094116, + 0.01526758074760437 + ] + }, + { + "backend": "torch", + "case": "random_effects_nonrobust", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.01991480588912964, + "samples_seconds": [ + 0.019420921802520752, + 0.020776748657226562, + 0.01991480588912964 + ] + }, + { + "backend": "torch", + "case": "random_effects_hc3", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.016228199005126953, + "samples_seconds": [ + 0.016228199005126953, + 0.016271233558654785, + 0.01610669493675232 + ] + }, + { + "backend": "cupy", + "case": "pooled_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.01036447286605835, + "samples_seconds": [ + 0.010409116744995117, + 0.010326117277145386, + 0.01036447286605835 + ] + }, + { + "backend": "cupy", + "case": "pooled_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.008398741483688354, + "samples_seconds": [ + 0.008391469717025757, + 0.008398741483688354, + 0.008414655923843384 + ] + }, + { + "backend": "cupy", + "case": "pooled_cluster_two_way", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.08064451813697815, + "samples_seconds": [ + 0.08210247755050659, + 0.08049970865249634, + 0.08064451813697815 + ] + }, + { + "backend": "cupy", + "case": "pooled_dk_qs", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.014240890741348267, + "samples_seconds": [ + 0.014040827751159668, + 0.014296621084213257, + 0.014240890741348267 + ] + }, + { + "backend": "cupy", + "case": "panel_entity_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.055529892444610596, + "samples_seconds": [ + 0.055529892444610596, + 0.0556337833404541, + 0.05530795454978943 + ] + }, + { + "backend": "cupy", + "case": "panel_entity_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.04133808612823486, + "samples_seconds": [ + 0.04133808612823486, + 0.04116940498352051, + 0.04142308235168457 + ] + }, + { + "backend": "cupy", + "case": "panel_entity_dk", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.055884361267089844, + "samples_seconds": [ + 0.055884361267089844, + 0.056315481662750244, + 0.055756330490112305 + ] + }, + { + "backend": "cupy", + "case": "random_effects_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.0711129903793335, + "samples_seconds": [ + 0.07123497128486633, + 0.0696721076965332, + 0.0711129903793335 + ] + }, + { + "backend": "cupy", + "case": "random_effects_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.05842083692550659, + "samples_seconds": [ + 0.05840688943862915, + 0.05842083692550659, + 0.05954203009605408 + ] + }, + { + "backend": "torch", + "case": "pooled_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.011348128318786621, + "samples_seconds": [ + 0.01147809624671936, + 0.011348128318786621, + 0.011211216449737549 + ] + }, + { + "backend": "torch", + "case": "pooled_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.010054141283035278, + "samples_seconds": [ + 0.010061025619506836, + 0.01002568006515503, + 0.010054141283035278 + ] + }, + { + "backend": "torch", + "case": "pooled_cluster_two_way", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.08115121722221375, + "samples_seconds": [ + 0.08023813366889954, + 0.08258581161499023, + 0.08115121722221375 + ] + }, + { + "backend": "torch", + "case": "pooled_dk_qs", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.01571902632713318, + "samples_seconds": [ + 0.01571902632713318, + 0.015740185976028442, + 0.01568007469177246 + ] + }, + { + "backend": "torch", + "case": "panel_entity_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.05339190363883972, + "samples_seconds": [ + 0.05339190363883972, + 0.05347055196762085, + 0.05215048789978027 + ] + }, + { + "backend": "torch", + "case": "panel_entity_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.039745837450027466, + "samples_seconds": [ + 0.039745837450027466, + 0.039325445890426636, + 0.040955543518066406 + ] + }, + { + "backend": "torch", + "case": "panel_entity_dk", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.05619451403617859, + "samples_seconds": [ + 0.05634602904319763, + 0.05619451403617859, + 0.05587249994277954 + ] + }, + { + "backend": "torch", + "case": "random_effects_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.06975138187408447, + "samples_seconds": [ + 0.06999918818473816, + 0.06975138187408447, + 0.06957536935806274 + ] + }, + { + "backend": "torch", + "case": "random_effects_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.057154446840286255, + "samples_seconds": [ + 0.057154446840286255, + 0.057167649269104004, + 0.057007044553756714 + ] + }, + { + "backend": "cupy", + "case": "pooled_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.01720249652862549, + "samples_seconds": [ + 0.017277419567108154, + 0.01720249652862549, + 0.017180174589157104 + ] + }, + { + "backend": "cupy", + "case": "pooled_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.013465136289596558, + "samples_seconds": [ + 0.013585954904556274, + 0.013465136289596558, + 0.013357192277908325 + ] + }, + { + "backend": "cupy", + "case": "pooled_cluster_two_way", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.08497023582458496, + "samples_seconds": [ + 0.08828312158584595, + 0.0848093032836914, + 0.08497023582458496 + ] + }, + { + "backend": "cupy", + "case": "pooled_dk_qs", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.017885267734527588, + "samples_seconds": [ + 0.017885267734527588, + 0.017872899770736694, + 0.0185183584690094 + ] + }, + { + "backend": "cupy", + "case": "panel_entity_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.12716519832611084, + "samples_seconds": [ + 0.12725773453712463, + 0.12716519832611084, + 0.1271631121635437 + ] + }, + { + "backend": "cupy", + "case": "panel_entity_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.0934441089630127, + "samples_seconds": [ + 0.0934441089630127, + 0.09339654445648193, + 0.09361585974693298 + ] + }, + { + "backend": "cupy", + "case": "panel_entity_dk", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.106719970703125, + "samples_seconds": [ + 0.10595273971557617, + 0.106719970703125, + 0.10740011930465698 + ] + }, + { + "backend": "cupy", + "case": "random_effects_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.19856467843055725, + "samples_seconds": [ + 0.19856467843055725, + 0.19973015785217285, + 0.19657310843467712 + ] + }, + { + "backend": "cupy", + "case": "random_effects_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.16259485483169556, + "samples_seconds": [ + 0.16259485483169556, + 0.16290101408958435, + 0.1594458818435669 + ] + }, + { + "backend": "torch", + "case": "pooled_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.01699233055114746, + "samples_seconds": [ + 0.017265766859054565, + 0.016991227865219116, + 0.01699233055114746 + ] + }, + { + "backend": "torch", + "case": "pooled_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.015967458486557007, + "samples_seconds": [ + 0.015988260507583618, + 0.015967458486557007, + 0.01590728759765625 + ] + }, + { + "backend": "torch", + "case": "pooled_cluster_two_way", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.09481719136238098, + "samples_seconds": [ + 0.097353994846344, + 0.09480512142181396, + 0.09481719136238098 + ] + }, + { + "backend": "torch", + "case": "pooled_dk_qs", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.02171957492828369, + "samples_seconds": [ + 0.02165377140045166, + 0.02171957492828369, + 0.02172139286994934 + ] + }, + { + "backend": "torch", + "case": "panel_entity_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.131193608045578, + "samples_seconds": [ + 0.1316295862197876, + 0.131193608045578, + 0.12670660018920898 + ] + }, + { + "backend": "torch", + "case": "panel_entity_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.097770094871521, + "samples_seconds": [ + 0.09625157713890076, + 0.097770094871521, + 0.0979669988155365 + ] + }, + { + "backend": "torch", + "case": "panel_entity_dk", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.11007392406463623, + "samples_seconds": [ + 0.11087656021118164, + 0.10961887240409851, + 0.11007392406463623 + ] + }, + { + "backend": "torch", + "case": "random_effects_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.18703612685203552, + "samples_seconds": [ + 0.18832719326019287, + 0.18581262230873108, + 0.18703612685203552 + ] + }, + { + "backend": "torch", + "case": "random_effects_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.1568531095981598, + "samples_seconds": [ + 0.17498546838760376, + 0.1568531095981598, + 0.151791512966156 + ] + }, + { + "backend": "cupy", + "case": "pooled_dk_qs", + "scenario": "high_t_qs", + "n_samples": 10000, + "n_features": 2, + "n_times": 200, + "repeats": 3, + "median_seconds": 0.024679750204086304, + "samples_seconds": [ + 0.024679750204086304, + 0.024548500776290894, + 0.024706721305847168 + ] + }, + { + "backend": "cupy", + "case": "panel_entity_dk_qs", + "scenario": "high_t_qs", + "n_samples": 10000, + "n_features": 2, + "n_times": 200, + "repeats": 3, + "median_seconds": 0.03359004855155945, + "samples_seconds": [ + 0.03193843364715576, + 0.033833831548690796, + 0.03359004855155945 + ] + }, + { + "backend": "torch", + "case": "pooled_dk_qs", + "scenario": "high_t_qs", + "n_samples": 10000, + "n_features": 2, + "n_times": 200, + "repeats": 3, + "median_seconds": 0.01733332872390747, + "samples_seconds": [ + 0.017191141843795776, + 0.017435550689697266, + 0.01733332872390747 + ] + }, + { + "backend": "torch", + "case": "panel_entity_dk_qs", + "scenario": "high_t_qs", + "n_samples": 10000, + "n_features": 2, + "n_times": 200, + "repeats": 3, + "median_seconds": 0.024563759565353394, + "samples_seconds": [ + 0.024627000093460083, + 0.024563759565353394, + 0.024269193410873413 + ] + } + ] +} diff --git a/results/pr126_p100/panel_stage_c_performance_c151550a.json b/results/pr126_p100/panel_stage_c_performance_c151550a.json new file mode 100644 index 000000000..e6495802d --- /dev/null +++ b/results/pr126_p100/panel_stage_c_performance_c151550a.json @@ -0,0 +1,895 @@ +{ + "schema_version": 2, + "git_sha": "c151550ab17bd9533a51599f86b6a4ea12a292e9", + "working_tree_clean": true, + "benchmark": "panel_stage_c_covariance_fit_overhead", + "timing_scope": "synchronized end-to-end estimator fit", + "input_residency": "X/y/entity/time preloaded on selected GPU backend; cluster labels remain CPU metadata", + "high_t_scale": "10000x2x200", + "environment": { + "python": "3.9.16", + "platform": "Linux-3.10.0-1062.el7.x86_64-x86_64-with-glibc2.31", + "gpu_by_backend": { + "cupy": "Tesla P100-SXM2-16GB", + "torch": "Tesla P100-SXM2-16GB" + }, + "packages": { + "statgpu": "0.2.4", + "numpy": "1.24.2", + "cupy": null, + "torch": "2.0.0" + } + }, + "rows": [ + { + "backend": "cupy", + "case": "pooled_nonrobust", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.005979597568511963, + "samples_seconds": [ + 0.006160944700241089, + 0.005979597568511963, + 0.005860358476638794 + ] + }, + { + "backend": "cupy", + "case": "pooled_hc3", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.005747348070144653, + "samples_seconds": [ + 0.005703955888748169, + 0.005747348070144653, + 0.0058464109897613525 + ] + }, + { + "backend": "cupy", + "case": "pooled_cluster_two_way", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.013141721487045288, + "samples_seconds": [ + 0.013141721487045288, + 0.013360321521759033, + 0.013063192367553711 + ] + }, + { + "backend": "cupy", + "case": "pooled_dk_qs", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.008118420839309692, + "samples_seconds": [ + 0.008118420839309692, + 0.008068680763244629, + 0.00815802812576294 + ] + }, + { + "backend": "cupy", + "case": "panel_entity_nonrobust", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.017401963472366333, + "samples_seconds": [ + 0.01755547523498535, + 0.017308861017227173, + 0.017401963472366333 + ] + }, + { + "backend": "cupy", + "case": "panel_entity_hc3", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.014687180519104004, + "samples_seconds": [ + 0.014687180519104004, + 0.014447033405303955, + 0.014759421348571777 + ] + }, + { + "backend": "cupy", + "case": "panel_entity_dk", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.016283273696899414, + "samples_seconds": [ + 0.016283273696899414, + 0.016127556562423706, + 0.016473501920700073 + ] + }, + { + "backend": "cupy", + "case": "random_effects_nonrobust", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.02007386088371277, + "samples_seconds": [ + 0.019605129957199097, + 0.020282089710235596, + 0.02007386088371277 + ] + }, + { + "backend": "cupy", + "case": "random_effects_hc3", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.017947852611541748, + "samples_seconds": [ + 0.0177304744720459, + 0.01865607500076294, + 0.017947852611541748 + ] + }, + { + "backend": "torch", + "case": "pooled_nonrobust", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.00681266188621521, + "samples_seconds": [ + 0.006932199001312256, + 0.00681266188621521, + 0.006681531667709351 + ] + }, + { + "backend": "torch", + "case": "pooled_hc3", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.006443411111831665, + "samples_seconds": [ + 0.0063333213329315186, + 0.006443411111831665, + 0.006444007158279419 + ] + }, + { + "backend": "torch", + "case": "pooled_cluster_two_way", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.012409061193466187, + "samples_seconds": [ + 0.013116717338562012, + 0.012343406677246094, + 0.012409061193466187 + ] + }, + { + "backend": "torch", + "case": "pooled_dk_qs", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.007998675107955933, + "samples_seconds": [ + 0.00814470648765564, + 0.00797697901725769, + 0.007998675107955933 + ] + }, + { + "backend": "torch", + "case": "panel_entity_nonrobust", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.014428496360778809, + "samples_seconds": [ + 0.014413982629776001, + 0.014475256204605103, + 0.014428496360778809 + ] + }, + { + "backend": "torch", + "case": "panel_entity_hc3", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.012241065502166748, + "samples_seconds": [ + 0.012275457382202148, + 0.01220482587814331, + 0.012241065502166748 + ] + }, + { + "backend": "torch", + "case": "panel_entity_dk", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.013953447341918945, + "samples_seconds": [ + 0.013953447341918945, + 0.013942182064056396, + 0.014147192239761353 + ] + }, + { + "backend": "torch", + "case": "random_effects_nonrobust", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.01686808466911316, + "samples_seconds": [ + 0.016668319702148438, + 0.01686808466911316, + 0.017150163650512695 + ] + }, + { + "backend": "torch", + "case": "random_effects_hc3", + "scenario": "base", + "n_samples": 10000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.014573752880096436, + "samples_seconds": [ + 0.01456671953201294, + 0.01478034257888794, + 0.014573752880096436 + ] + }, + { + "backend": "cupy", + "case": "pooled_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.0084761381149292, + "samples_seconds": [ + 0.008516639471054077, + 0.0084761381149292, + 0.008447915315628052 + ] + }, + { + "backend": "cupy", + "case": "pooled_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.007394284009933472, + "samples_seconds": [ + 0.007394284009933472, + 0.007409781217575073, + 0.0073799192905426025 + ] + }, + { + "backend": "cupy", + "case": "pooled_cluster_two_way", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.07351970672607422, + "samples_seconds": [ + 0.07483908534049988, + 0.07351970672607422, + 0.07301801443099976 + ] + }, + { + "backend": "cupy", + "case": "pooled_dk_qs", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.01236182451248169, + "samples_seconds": [ + 0.012312859296798706, + 0.01236182451248169, + 0.01261088252067566 + ] + }, + { + "backend": "cupy", + "case": "panel_entity_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.050304561853408813, + "samples_seconds": [ + 0.05175486207008362, + 0.050271421670913696, + 0.050304561853408813 + ] + }, + { + "backend": "cupy", + "case": "panel_entity_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.03811576962471008, + "samples_seconds": [ + 0.03811576962471008, + 0.038228780031204224, + 0.03724789619445801 + ] + }, + { + "backend": "cupy", + "case": "panel_entity_dk", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.050720542669296265, + "samples_seconds": [ + 0.05152568221092224, + 0.050720542669296265, + 0.05049818754196167 + ] + }, + { + "backend": "cupy", + "case": "random_effects_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.06707775592803955, + "samples_seconds": [ + 0.06707775592803955, + 0.06636276841163635, + 0.06797653436660767 + ] + }, + { + "backend": "cupy", + "case": "random_effects_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.054088056087493896, + "samples_seconds": [ + 0.054088056087493896, + 0.054762035608291626, + 0.05336660146713257 + ] + }, + { + "backend": "torch", + "case": "pooled_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.008630365133285522, + "samples_seconds": [ + 0.00877031683921814, + 0.008630365133285522, + 0.008608430624008179 + ] + }, + { + "backend": "torch", + "case": "pooled_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.008865267038345337, + "samples_seconds": [ + 0.008872270584106445, + 0.008847326040267944, + 0.008865267038345337 + ] + }, + { + "backend": "torch", + "case": "pooled_cluster_two_way", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.07636550068855286, + "samples_seconds": [ + 0.07610204815864563, + 0.07636550068855286, + 0.08064335584640503 + ] + }, + { + "backend": "torch", + "case": "pooled_dk_qs", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.014457523822784424, + "samples_seconds": [ + 0.014428943395614624, + 0.014457523822784424, + 0.014459073543548584 + ] + }, + { + "backend": "torch", + "case": "panel_entity_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.05001285672187805, + "samples_seconds": [ + 0.049780040979385376, + 0.05001285672187805, + 0.051658302545547485 + ] + }, + { + "backend": "torch", + "case": "panel_entity_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.03962758183479309, + "samples_seconds": [ + 0.038950115442276, + 0.03962758183479309, + 0.04026085138320923 + ] + }, + { + "backend": "torch", + "case": "panel_entity_dk", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.05592408776283264, + "samples_seconds": [ + 0.05592408776283264, + 0.05507385730743408, + 0.056911736726760864 + ] + }, + { + "backend": "torch", + "case": "random_effects_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.06500598788261414, + "samples_seconds": [ + 0.0657675564289093, + 0.06500598788261414, + 0.06417113542556763 + ] + }, + { + "backend": "torch", + "case": "random_effects_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 2, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.054270654916763306, + "samples_seconds": [ + 0.054270654916763306, + 0.05694356560707092, + 0.05380934476852417 + ] + }, + { + "backend": "cupy", + "case": "pooled_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.012790769338607788, + "samples_seconds": [ + 0.012857705354690552, + 0.012790769338607788, + 0.0127582848072052 + ] + }, + { + "backend": "cupy", + "case": "pooled_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.011051684617996216, + "samples_seconds": [ + 0.011053264141082764, + 0.01104852557182312, + 0.011051684617996216 + ] + }, + { + "backend": "cupy", + "case": "pooled_cluster_two_way", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.07384097576141357, + "samples_seconds": [ + 0.07415291666984558, + 0.07384097576141357, + 0.07253557443618774 + ] + }, + { + "backend": "cupy", + "case": "pooled_dk_qs", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.01554858684539795, + "samples_seconds": [ + 0.01558607816696167, + 0.015419244766235352, + 0.01554858684539795 + ] + }, + { + "backend": "cupy", + "case": "panel_entity_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.12529221177101135, + "samples_seconds": [ + 0.12529221177101135, + 0.1251654326915741, + 0.12606588006019592 + ] + }, + { + "backend": "cupy", + "case": "panel_entity_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.09376078844070435, + "samples_seconds": [ + 0.09115254878997803, + 0.09447228908538818, + 0.09376078844070435 + ] + }, + { + "backend": "cupy", + "case": "panel_entity_dk", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.10945910215377808, + "samples_seconds": [ + 0.10945910215377808, + 0.11083570122718811, + 0.10487332940101624 + ] + }, + { + "backend": "cupy", + "case": "random_effects_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.1875428855419159, + "samples_seconds": [ + 0.1875428855419159, + 0.1936834454536438, + 0.18730005621910095 + ] + }, + { + "backend": "cupy", + "case": "random_effects_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.1521417796611786, + "samples_seconds": [ + 0.1521417796611786, + 0.15149375796318054, + 0.1536262035369873 + ] + }, + { + "backend": "torch", + "case": "pooled_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.01250767707824707, + "samples_seconds": [ + 0.012714773416519165, + 0.012506604194641113, + 0.01250767707824707 + ] + }, + { + "backend": "torch", + "case": "pooled_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.014070868492126465, + "samples_seconds": [ + 0.014074325561523438, + 0.014033019542694092, + 0.014070868492126465 + ] + }, + { + "backend": "torch", + "case": "pooled_cluster_two_way", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.07722008228302002, + "samples_seconds": [ + 0.07722008228302002, + 0.07699701189994812, + 0.08336886763572693 + ] + }, + { + "backend": "torch", + "case": "pooled_dk_qs", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.01908847689628601, + "samples_seconds": [ + 0.019063949584960938, + 0.019156605005264282, + 0.01908847689628601 + ] + }, + { + "backend": "torch", + "case": "panel_entity_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.1263706088066101, + "samples_seconds": [ + 0.1263706088066101, + 0.12504175305366516, + 0.1266615390777588 + ] + }, + { + "backend": "torch", + "case": "panel_entity_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.0949026346206665, + "samples_seconds": [ + 0.09489509463310242, + 0.0949026346206665, + 0.0989454984664917 + ] + }, + { + "backend": "torch", + "case": "panel_entity_dk", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.10839793086051941, + "samples_seconds": [ + 0.10839793086051941, + 0.10947087407112122, + 0.10752084851264954 + ] + }, + { + "backend": "torch", + "case": "random_effects_nonrobust", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.1900160014629364, + "samples_seconds": [ + 0.1887923777103424, + 0.19474482536315918, + 0.1900160014629364 + ] + }, + { + "backend": "torch", + "case": "random_effects_hc3", + "scenario": "base", + "n_samples": 100000, + "n_features": 10, + "n_times": 20, + "repeats": 3, + "median_seconds": 0.15308168530464172, + "samples_seconds": [ + 0.15223956108093262, + 0.15328919887542725, + 0.15308168530464172 + ] + }, + { + "backend": "cupy", + "case": "pooled_dk_qs", + "scenario": "high_t_qs", + "n_samples": 10000, + "n_features": 2, + "n_times": 200, + "repeats": 3, + "median_seconds": 0.02344447374343872, + "samples_seconds": [ + 0.023430943489074707, + 0.023461490869522095, + 0.02344447374343872 + ] + }, + { + "backend": "cupy", + "case": "panel_entity_dk_qs", + "scenario": "high_t_qs", + "n_samples": 10000, + "n_features": 2, + "n_times": 200, + "repeats": 3, + "median_seconds": 0.03237190842628479, + "samples_seconds": [ + 0.031690001487731934, + 0.03237190842628479, + 0.03253546357154846 + ] + }, + { + "backend": "torch", + "case": "pooled_dk_qs", + "scenario": "high_t_qs", + "n_samples": 10000, + "n_features": 2, + "n_times": 200, + "repeats": 3, + "median_seconds": 0.01615041494369507, + "samples_seconds": [ + 0.01615041494369507, + 0.01625990867614746, + 0.01581135392189026 + ] + }, + { + "backend": "torch", + "case": "panel_entity_dk_qs", + "scenario": "high_t_qs", + "n_samples": 10000, + "n_features": 2, + "n_times": 200, + "repeats": 3, + "median_seconds": 0.023040443658828735, + "samples_seconds": [ + 0.023040443658828735, + 0.02325156331062317, + 0.022928446531295776 + ] + } + ] +} diff --git a/statgpu/__init__.py b/statgpu/__init__.py index 9fcab6a11..bed6786a8 100644 --- a/statgpu/__init__.py +++ b/statgpu/__init__.py @@ -60,6 +60,7 @@ pooling_f_test, breusch_pagan_lm_test, hac_covariance, + driscoll_kraay_covariance, ) from .backends import get_backend, NumpyBackend, CuPyBackend, TorchBackend from .metrics import evaluate_binary_classification @@ -191,6 +192,7 @@ "pooling_f_test", "breusch_pagan_lm_test", "hac_covariance", + "driscoll_kraay_covariance", # Backends "get_backend", "NumpyBackend", diff --git a/statgpu/panel/__init__.py b/statgpu/panel/__init__.py index 262f9e1c2..71f0661af 100644 --- a/statgpu/panel/__init__.py +++ b/statgpu/panel/__init__.py @@ -8,7 +8,12 @@ from ._fixed_effects import PanelOLS, FixedEffects from ._random_effects import RandomEffects, RandomEffectsOLS -from ._covariance import clustered_covariance, two_way_clustered_covariance, hac_covariance +from ._covariance import ( + clustered_covariance, + two_way_clustered_covariance, + hac_covariance, + driscoll_kraay_covariance, +) from ._utils import PanelSummary from ._results import PanelTestResult, PanelFitStatistics from ._diagnostics import hausman_test, pooling_f_test, breusch_pagan_lm_test @@ -35,4 +40,5 @@ 'clustered_covariance', 'two_way_clustered_covariance', 'hac_covariance', + 'driscoll_kraay_covariance', ] diff --git a/statgpu/panel/_base.py b/statgpu/panel/_base.py index c7cbb96a2..8e497894a 100644 --- a/statgpu/panel/_base.py +++ b/statgpu/panel/_base.py @@ -15,7 +15,11 @@ from statgpu._base import BaseEstimator from statgpu.backends import _to_numpy, xp_asarray, xp_maximum, xp_ones from statgpu.panel._results import build_panel_index_info -from statgpu.panel._utils import PanelSummary, validate_panel_alpha, validate_panel_numeric_data +from statgpu.panel._utils import ( + PanelSummary, + validate_panel_alpha, + validate_panel_numeric_data, +) class BasePanelModel(BaseEstimator): @@ -32,7 +36,10 @@ def _panel_prepare_formula_fit( support_pipe: bool = False, side_arrays: Optional[Dict[str, object]] = None, ): - from statgpu.panel._formula import _align_formula_side_array, _prepare_formula_fit + from statgpu.panel._formula import ( + _align_formula_side_array, + _prepare_formula_fit, + ) ( y_data, @@ -81,12 +88,18 @@ def _panel_prepare_numeric(self, X, y, *, validate_alpha: bool = True): X_device = self._to_array(X, backend=backend.name) y_device = self._to_array(y, backend=backend.name) X_arr = xp_asarray(X_device, dtype=xp.float64, xp=xp) - y_arr = xp_asarray(y_device, dtype=xp.float64, xp=xp, ref_arr=X_arr).ravel() + y_arr = xp_asarray( + y_device, dtype=xp.float64, xp=xp, ref_arr=X_arr + ).ravel() if X_arr.ndim == 1: X_arr = X_arr.reshape(-1, 1) if validate_alpha and hasattr(self, "alpha"): validate_panel_alpha(self.alpha) validate_panel_numeric_data(X_arr, y_arr, xp) + # Persist the backend actually selected at the numerical fit boundary. + # Physical validation must not reconstruct this provenance later from + # the requested device, since that cannot detect a silent fallback. + self._backend_name = backend.name return backend, xp, X_arr, y_arr def _panel_set_index_info(self, nobs, *, entity_ids=None, time_ids=None): @@ -96,6 +109,27 @@ def _panel_set_index_info(self, nobs, *, entity_ids=None, time_ids=None): self._panel_index_info = info return info + def set_params(self, **params): + """Set estimator parameters and refresh panel covariance aliases. + + ``BaseEstimator`` deliberately preserves the exact user-supplied public + constructor value for sklearn constructor identity. Panel covariance + dispatch, however, uses the normalized private ``_cov_type`` runtime + value. Refresh only that private value after sklearn-style parameter + updates so ``hc1``/``dk``/``kernel`` behave exactly like direct + construction without changing the public raw parameter. + """ + if "group_debias" in params and not isinstance( + params["group_debias"], (bool, np.bool_) + ): + raise ValueError("group_debias must be boolean") + result = super().set_params(**params) + if "cov_type" in params and hasattr(self, "cov_type"): + from statgpu.panel._covariance import normalize_covariance_type + + self._cov_type = normalize_covariance_type(self.cov_type) + return result + @property def _panel_cov_params(self): """Return the small covariance matrix used by Stage-B diagnostics. @@ -163,7 +197,9 @@ def _panel_predict_linear( X_arr = xp.concatenate([ones, X_arr], axis=1) value = self.coef_ if params is None else params - params_dev = xp_asarray(value, dtype=xp.float64, xp=xp, ref_arr=X_arr).ravel() + params_dev = xp_asarray( + value, dtype=xp.float64, xp=xp, ref_arr=X_arr + ).ravel() if int(X_arr.shape[1]) != int(params_dev.shape[0]): raise ValueError("X has an incompatible feature count") prediction = X_arr @ params_dev @@ -180,56 +216,79 @@ def _panel_store_ols_inference( backend, cov_type, cluster=None, + time_ids=None, bandwidth=None, kernel="bartlett", + group_debias: bool = False, + extra_df: int = 0, allowed=None, hc1_correction=None, distribution_df=None, diag_floor=1e-30, ): - """Store existing residual-based OLS inference from the shared registry.""" + """Store residual-based OLS inference from the shared covariance registry.""" from statgpu.inference._distributions_backend import get_distribution - from statgpu.panel._covariance import ols_covariance + from statgpu.inference._results import ParameterInferenceResult + from statgpu.panel._covariance import ( + normalize_covariance_type, + ols_covariance, + ) xp = backend.xp + canonical_cov_type = normalize_covariance_type(cov_type) + covariance_metadata: dict = {} cov_params = ols_covariance( X, resid, - cov_type=cov_type, + cov_type=canonical_cov_type, scale=scale, df_resid=df_resid, cluster=cluster, + time_ids=time_ids, bandwidth=bandwidth, kernel=kernel, + group_debias=group_debias, + extra_df=extra_df, xp=xp, allowed=allowed, hc1_correction=hc1_correction, + metadata=covariance_metadata, ) - # 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._covariance_metadata = covariance_metadata self._panel_cov_params_raw = np.asarray( _to_numpy(cov_params), dtype=np.float64 ) diag = xp.diag(cov_params) + diag_np = np.asarray(_to_numpy(diag), dtype=np.float64).ravel() + negative_tol = ( + 4096.0 + * np.finfo(np.float64).eps + * np.maximum(1.0, np.abs(diag_np)) + ) + if np.any(diag_np < -negative_tol): + raise ValueError( + "covariance has materially negative diagonal variance; " + "inference is not numerically valid" + ) + # Only suppress elementwise roundoff-scale negative zeros. A material + # negative variance must fail closed before any historical diagonal floor + # is used, even when another coefficient has a much larger variance. + diag = xp_maximum(diag, 0.0, xp) if diag_floor is not None: diag = xp_maximum(diag, float(diag_floor), xp) bse_dev = xp.sqrt(diag) if diag_floor is None: tvalues_dev = params / bse_dev else: - denominator = xp_maximum(bse_dev, np.finfo(np.float64).tiny, xp) + denominator = xp_maximum( + bse_dev, np.finfo(np.float64).tiny, xp + ) tvalues_dev = params / denominator - dist_name = "t" if str(cov_type).lower() == "nonrobust" else "norm" + dist_name = "t" if canonical_cov_type == "nonrobust" else "norm" df = int(df_resid if distribution_df is None else distribution_df) 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) @@ -254,6 +313,25 @@ def _panel_store_ols_inference( self.conf_int_ = np.asarray( _to_numpy(xp.stack([conf_low, conf_high], axis=1)) ) + + feature_names = getattr(self, "_feature_names", None) + if feature_names is not None and len(feature_names) != len(self.coef_): + feature_names = None + inference = ParameterInferenceResult( + method="panel_ols", + feature_names=feature_names, + metadata={"covariance": dict(covariance_metadata)}, + params=self.coef_, + bse=self.bse_, + statistic=self.tvalues_, + statistic_name="t" if dist_name == "t" else "z", + pvalues=self.pvalues_, + conf_int=self.conf_int_, + cov_type=canonical_cov_type, + distribution="t" if dist_name == "t" else "normal", + df=float(df) if dist_name == "t" else None, + ) + inference.apply_to(self) return cov_params def _panel_summary( @@ -278,7 +356,9 @@ def _panel_summary( coef_np = np.asarray(_to_numpy(self.coef_)).ravel() if feature_names_override is None: feature_names = _get_feature_names( - getattr(self, "_feature_names", None), len(coef_np), prefix=prefix + getattr(self, "_feature_names", None), + len(coef_np), + prefix=prefix, ) else: feature_names = list(feature_names_override) @@ -303,4 +383,4 @@ def _panel_summary( ) if print_result: print(summary) - return summary \ No newline at end of file + return summary diff --git a/statgpu/panel/_between.py b/statgpu/panel/_between.py index c0ee8ca51..872118851 100644 --- a/statgpu/panel/_between.py +++ b/statgpu/panel/_between.py @@ -18,12 +18,14 @@ class BetweenOLS(BasePanelModel): """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. + An intercept is added automatically. Stage C adds transformed-fit-space + HC0/HC2/HC3 covariance while preserving the historical HC1 ``robust`` path. Parameters ---------- - cov_type : str, default='nonrobust' - Covariance estimator: ``'nonrobust'`` or ``'robust'`` (HC1). + cov_type : {'nonrobust', 'robust', 'hc0', 'hc1', 'hc2', 'hc3'}, default='nonrobust' + Covariance estimator. ``robust`` and ``hc1`` are the same historical + HC1 contract; HC2/HC3 use leverage from the entity-mean fit-space design. alpha : float, default=0.05 Significance level for confidence intervals. device : str or Device, default='auto' @@ -38,9 +40,9 @@ class BetweenOLS(BasePanelModel): bse_ : ndarray, shape (k,) Standard errors. tvalues_ : ndarray, shape (k,) - t-statistics. + Coefficient test statistics. pvalues_ : ndarray, shape (k,) - Two-sided p-values. + Coefficient p-values. conf_int_ : ndarray, shape (k, 2) Confidence intervals. rsquared : float @@ -61,16 +63,18 @@ def __init__( n_jobs: Optional[int] = None, ): super().__init__(device=device, n_jobs=n_jobs) - self.cov_type = cov_type.lower() + from statgpu.panel._covariance import normalize_covariance_type + + self.cov_type = normalize_covariance_type(cov_type) self.alpha = alpha - if self.cov_type not in ("nonrobust", "robust"): - raise ValueError("cov_type must be 'nonrobust' or 'robust'") + if self.cov_type not in ("nonrobust", "robust", "hc0", "hc2", "hc3"): + raise ValueError( + "cov_type must be one of 'nonrobust', 'robust', 'hc0', 'hc1', 'hc2', or 'hc3'" + ) 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") @@ -91,6 +95,11 @@ def fit(self, X=None, y=None, entity_ids=None, time_ids=None, formula=None, data side_arrays={"entity_ids": entity_ids}, ) entity_ids = aligned["entity_ids"] + if formula is not None and bool(self._formula_has_intercept): + self._feature_names = [ + "Intercept", + *list(self._feature_names or []), + ] backend, xp, X_arr, y_arr = self._panel_prepare_numeric(X_data, y_data) self._panel_set_index_info(X_arr.shape[0], entity_ids=entity_ids) @@ -103,7 +112,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) @@ -143,7 +151,7 @@ def fit(self, X=None, y=None, entity_ids=None, time_ids=None, formula=None, data df_resid=df_resid, backend=backend, cov_type=self._cov_type, - allowed=("nonrobust", "robust"), + allowed=("nonrobust", "robust", "hc0", "hc2", "hc3"), hc1_correction=n / df_resid if self._cov_type == "robust" else None, distribution_df=df_resid, diag_floor=1e-30, @@ -210,4 +218,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 diff --git a/statgpu/panel/_covariance.py b/statgpu/panel/_covariance.py index e312d5445..4f867d996 100644 --- a/statgpu/panel/_covariance.py +++ b/statgpu/panel/_covariance.py @@ -1,9 +1,10 @@ -""" -Covariance estimators and internal dispatch for panel data models. +"""Covariance estimators and internal dispatch for panel data models. -The public one-way/two-way cluster and HAC functions retain their existing -contracts. Stage A of issue #93 adds ``ols_covariance`` as an internal -behavior-preserving dispatcher for residual-based OLS/transformed-OLS models. +Stage C of Issue #93 extends the Stage-A residual-OLS covariance registry with +HC0/HC2/HC3, explicit cluster group debiasing, and Driscoll-Kraay covariance. +Covariance breads are built from the design pseudoinverse rather than normal +equations so full-rank but ill-conditioned designs do not square the condition +number before inference. """ from __future__ import annotations @@ -11,6 +12,8 @@ "clustered_covariance", "two_way_clustered_covariance", "hac_covariance", + "driscoll_kraay_covariance", + "normalize_covariance_type", "ols_covariance", ] @@ -19,121 +22,506 @@ import numpy as np from statgpu.backends import ( - _LINALG_ERRORS, + _get_xp, + _resolve_backend, + _to_float_scalar, _to_numpy, xp_asarray, xp_zeros, ) +from statgpu.panel._utils import factorize_panel_metadata + + +_COVARIANCE_ALIASES = { + "hc1": "robust", + "dk": "driscoll-kraay", + "kernel": "driscoll-kraay", +} + +_KERNEL_ALIASES = { + "bartlett": "bartlett", + "newey-west": "bartlett", + "parzen": "parzen", + "gallant": "parzen", + "quadratic-spectral": "qs", + "qs": "qs", + "andrews": "qs", +} + + +def normalize_covariance_type(cov_type: str) -> str: + """Return the canonical Stage-C covariance name.""" + name = str(cov_type).strip().lower() + return _COVARIANCE_ALIASES.get(name, name) + +def _ensure_xp(xp=None, *arrays): + """Return an explicit array module or infer it from public inputs.""" + if xp is not None: + return xp + return _get_xp(_resolve_backend("auto", *arrays)) -def _ensure_xp(xp=None): - """Return the array module, defaulting to numpy.""" - return xp if xp is not None else np +def _is_torch(xp) -> bool: + return getattr(xp, "__name__", "") == "torch" -def clustered_covariance(X, resid, clusters, xp=None): - """One-way clustered robust covariance matrix. - Implements the cluster-robust sandwich estimator:: +def _matrix_rank(X, xp) -> int: + return int(_to_float_scalar(xp.linalg.matrix_rank(X))) - V = (X'X/n)^{-1} @ meat @ (X'X/n)^{-1} / n^2 - where ``meat = sum_g (X_g' e_g)(X_g' e_g)'``. +def _design_pseudoinverse(X, xp): + """Return X+, (X'X)+ and numerical rank without forming X'X first.""" + X_pinv = xp.linalg.pinv(X) + bread = X_pinv @ X_pinv.T + return X_pinv, bread, _matrix_rank(X, xp) + + +def _gram_inverse(X, xp, *, rank_aware: bool = False): + """Compatibility helper returning a stable generalized inverse of X'X. + + ``rank_aware`` is retained for the existing internal signature. The stable + implementation always derives the bread from ``X+``; it never attempts + ``inv(X'X)`` merely because ``X`` is still classified as full rank. """ - xp = _ensure_xp(xp) + del rank_aware + _X_pinv, bread, rank = _design_pseudoinverse(X, xp) + return bread, rank + + +def _influence_rows(X, resid, xp): + """Return observation OLS influence rows e_i * ((X+)')_i.""" + X_pinv, bread, rank = _design_pseudoinverse(X, xp) + influence = X_pinv.T * resid[:, None] + return influence, X_pinv, bread, rank + + +def _symmetrize(matrix): + return 0.5 * (matrix + matrix.T) + + +def _grouped_score_sums(scores, codes_np, *, n_groups: int, xp): + """Sum an observation-by-parameter score matrix by integer group code.""" + codes_np = np.asarray(codes_np, dtype=np.int64).ravel() + if codes_np.shape[0] != int(scores.shape[0]): + raise ValueError("group codes must match the number of score rows") + if int(n_groups) <= 0: + raise ValueError("at least one group is required") + codes = xp_asarray( + codes_np, + dtype=xp.int64, + xp=xp, + ref_arr=scores, + ) + out = xp_zeros( + (int(n_groups), int(scores.shape[1])), + dtype=xp.float64, + xp=xp, + ref_arr=scores, + ) + if hasattr(out, "scatter_add_"): + out.scatter_add_(0, codes.unsqueeze(1).expand_as(scores), scores) + elif type(out).__module__.startswith("cupy"): + xp.add.at(out, codes, scores) + else: + np.add.at(out, codes_np, scores) + return out + + +def _factorize_1d_labels(values, *, nobs: int, name: str): + labels, codes = factorize_panel_metadata( + values, name=name, expected_n=int(nobs) + ) + return labels, codes + + +def _paired_codes(left, right): + pairs = np.column_stack( + [np.asarray(left, dtype=np.int64), np.asarray(right, dtype=np.int64)] + ) + _, codes = np.unique(pairs, axis=0, return_inverse=True) + return codes.astype(np.int64, copy=False) + + +def _group_debias_factor(n_groups: int, nobs: int) -> float: + n_groups = int(n_groups) + nobs = int(nobs) + if n_groups < 2: + raise ValueError("group_debias requires at least two groups") + if nobs <= 0: + raise ValueError("group_debias requires a positive observation count") + return (n_groups / (n_groups - 1.0)) * ((nobs - 1.0) / nobs) + + +def _validate_group_debias(value) -> bool: + if not isinstance(value, (bool, np.bool_)): + raise ValueError("group_debias must be boolean") + return bool(value) + + +def clustered_covariance( + X, + resid, + clusters, + xp=None, + *, + group_debias: bool = False, + metadata: Optional[dict] = None, +): + """One-way clustered robust covariance matrix.""" + xp = _ensure_xp(xp, X) + group_debias = _validate_group_debias(group_debias) - clusters_np = np.asarray(_to_numpy(clusters)).ravel() X = xp_asarray(X, dtype=xp.float64, xp=xp) resid = xp_asarray(resid, dtype=xp.float64, xp=xp, ref_arr=X).ravel() - if X.ndim != 2: raise ValueError("X must be two-dimensional") - n, k = X.shape - if resid.shape[0] != n or clusters_np.shape[0] != n: - raise ValueError("X, resid, and clusters must have the same number of observations") - - XtX = X.T @ X / n - try: - bread = xp.linalg.inv(XtX) - except _LINALG_ERRORS: - bread = xp.linalg.pinv(XtX) - - scores = X * resid[:, None] - unique_labels, cluster_idx = np.unique(clusters_np, return_inverse=True) - n_clusters = len(unique_labels) - cluster_idx_xp = xp_asarray(cluster_idx, dtype=xp.int64, xp=xp, ref_arr=X) - - S = xp_zeros((n_clusters, k), dtype=xp.float64, xp=xp, ref_arr=X) - if hasattr(S, "scatter_add_"): - S.scatter_add_(0, cluster_idx_xp.unsqueeze(1).expand_as(scores), scores) - elif type(S).__module__.startswith("cupy"): - xp.add.at(S, cluster_idx_xp, scores) - else: - np.add.at(S, cluster_idx, scores) - - meat = S.T @ S - return bread @ meat @ bread / (n * n) - + n, _k = X.shape + labels, cluster_idx = _factorize_1d_labels( + clusters, nobs=int(n), name="clusters" + ) + if resid.shape[0] != n: + raise ValueError("X and resid must have the same number of observations") -def two_way_clustered_covariance(X, resid, cluster1, cluster2, xp=None): - """Two-way clustered covariance with intersection correction.""" - xp = _ensure_xp(xp) + influence, _X_pinv, _bread, _rank = _influence_rows(X, resid, xp) + n_clusters = int(len(labels)) + grouped = _grouped_score_sums( + influence, cluster_idx, n_groups=n_clusters, xp=xp + ) + correction = 1.0 + if group_debias: + correction = _group_debias_factor(n_clusters, int(n)) + cov = _symmetrize(grouped.T @ grouped * float(correction)) + if metadata is not None: + metadata.update( + { + "cluster_dimensions": 1, + "cluster_group_counts": [n_clusters], + "group_debias": bool(group_debias), + "group_debias_factors": [float(correction)], + } + ) + return cov - V1 = clustered_covariance(X, resid, cluster1, xp) - V2 = clustered_covariance(X, resid, cluster2, xp) - c1_raw = np.asarray(_to_numpy(cluster1)).ravel() - c2_raw = np.asarray(_to_numpy(cluster2)).ravel() +def two_way_clustered_covariance( + X, + resid, + cluster1, + cluster2, + xp=None, + *, + group_debias: bool = False, + metadata: Optional[dict] = None, +): + """Two-way clustered covariance with exact intersection factorization.""" + xp = _ensure_xp(xp, X) + group_debias = _validate_group_debias(group_debias) n = int(X.shape[0]) - if c1_raw.shape[0] != n or c2_raw.shape[0] != n: - raise ValueError("cluster arrays must match the number of observations") - _, c1 = np.unique(c1_raw, return_inverse=True) - _, c2 = np.unique(c2_raw, return_inverse=True) - s = c1.astype(np.int64) + c2.astype(np.int64) - combined_np = s * (s + 1) // 2 + c2.astype(np.int64) - combined = xp_asarray(combined_np, dtype=xp.int64, xp=xp, ref_arr=V1) - - V12 = clustered_covariance(X, resid, combined, xp) - return V1 + V2 - V12 + labels1, c1 = _factorize_1d_labels(cluster1, nobs=n, name="cluster1") + labels2, c2 = _factorize_1d_labels(cluster2, nobs=n, name="cluster2") + c12 = _paired_codes(c1, c2) + n12 = int(np.max(c12)) + 1 if c12.size else 0 + + meta1: dict = {} + meta2: dict = {} + meta12: dict = {} + V1 = clustered_covariance( + X, + resid, + c1, + xp, + group_debias=group_debias, + metadata=meta1, + ) + V2 = clustered_covariance( + X, + resid, + c2, + xp, + group_debias=group_debias, + metadata=meta2, + ) + V12 = clustered_covariance( + X, + resid, + c12, + xp, + group_debias=group_debias, + metadata=meta12, + ) + if metadata is not None: + metadata.update( + { + "cluster_dimensions": 2, + "cluster_group_counts": [ + int(len(labels1)), + int(len(labels2)), + n12, + ], + "group_debias": bool(group_debias), + "group_debias_factors": [ + float(meta1["group_debias_factors"][0]), + float(meta2["group_debias_factors"][0]), + float(meta12["group_debias_factors"][0]), + ], + } + ) + return _symmetrize(V1 + V2 - V12) def hac_covariance(X, resid, bandwidth=None, kernel="bartlett", xp=None): - """Newey-West HAC covariance using the Bartlett kernel.""" - xp = _ensure_xp(xp) + """Historical row-order Newey-West HAC covariance using Bartlett weights.""" + xp = _ensure_xp(xp, X) if str(kernel).lower() != "bartlett": raise ValueError("kernel must be 'bartlett'") if bandwidth is not None: - if isinstance(bandwidth, bool) or not isinstance(bandwidth, (int, np.integer)): + if isinstance(bandwidth, bool) or not isinstance( + bandwidth, (int, np.integer) + ): raise ValueError("bandwidth must be a non-negative integer or None") if int(bandwidth) < 0: raise ValueError("bandwidth must be a non-negative integer or None") X = xp_asarray(X, dtype=xp.float64, xp=xp) resid = xp_asarray(resid, dtype=xp.float64, xp=xp, ref_arr=X).ravel() - if X.ndim != 2 or resid.shape[0] != X.shape[0]: raise ValueError("X and resid must have matching observation counts") - n, _ = X.shape + n = int(X.shape[0]) if bandwidth is None: bandwidth = int(np.floor(4.0 * (n / 100.0) ** (2.0 / 9.0))) - bandwidth = max(0, min(bandwidth, n - 1)) - - XtX = X.T @ X / n - try: - bread = xp.linalg.inv(XtX) - except _LINALG_ERRORS: - bread = xp.linalg.pinv(XtX) - - scores = X * resid[:, None] - meat = scores.T @ scores / n + bandwidth = max(0, min(int(bandwidth), n - 1)) + influence, _X_pinv, _bread, _rank = _influence_rows(X, resid, xp) + cov = influence.T @ influence for h in range(1, bandwidth + 1): w = 1.0 - h / (bandwidth + 1.0) - gamma_h = scores[h:].T @ scores[: n - h] / n - meat = meat + w * (gamma_h + gamma_h.T) + gamma_h = influence[h:].T @ influence[: n - h] + cov = cov + w * (gamma_h + gamma_h.T) + return _symmetrize(cov) - return bread @ meat @ bread / n + +def _canonical_kernel(kernel: str) -> str: + name = str(kernel).strip().lower() + if name not in _KERNEL_ALIASES: + choices = ", ".join(sorted(_KERNEL_ALIASES)) + raise ValueError( + f"unsupported Driscoll-Kraay kernel {kernel!r}; expected one of: {choices}" + ) + return _KERNEL_ALIASES[name] + + +def _validate_dk_bandwidth(bandwidth, n_periods: int) -> int: + if bandwidth is None: + bandwidth = int(np.floor(4.0 * (n_periods / 100.0) ** (2.0 / 9.0))) + if isinstance(bandwidth, bool) or not isinstance( + bandwidth, (int, np.integer) + ): + raise ValueError( + "Driscoll-Kraay bandwidth must be a non-negative integer or None" + ) + bandwidth = int(bandwidth) + if bandwidth < 0: + raise ValueError( + "Driscoll-Kraay bandwidth must be a non-negative integer or None" + ) + # Explicit oversized bandwidths are smoothing parameters, not silently + # capped lags. Only observed lags can contribute to the covariance. + return bandwidth + + +def _dk_kernel_weights( + kernel: str, bandwidth: int, max_lag: int +) -> tuple[str, np.ndarray]: + """Return canonical DK kernel name and weights for lags 0..max_lag.""" + canonical = _canonical_kernel(kernel) + max_lag = int(max_lag) + bandwidth = int(bandwidth) + weights = np.zeros(max_lag + 1, dtype=np.float64) + weights[0] = 1.0 + if max_lag == 0 or bandwidth == 0: + return canonical, weights + + if canonical == "bartlett": + stop = min(bandwidth, max_lag) + lag = np.arange(1, stop + 1, dtype=np.float64) + weights[1 : stop + 1] = 1.0 - lag / (bandwidth + 1.0) + return canonical, weights + + if canonical == "parzen": + stop = min(bandwidth, max_lag) + lag = np.arange(1, stop + 1, dtype=np.float64) + z = lag / (bandwidth + 1.0) + low = z <= 0.5 + w = np.empty_like(z) + w[low] = 1.0 - 6.0 * z[low] ** 2 + 6.0 * z[low] ** 3 + w[~low] = 2.0 * (1.0 - z[~low]) ** 3 + weights[1 : stop + 1] = w + return canonical, weights + + # Quadratic spectral is not truncated at bandwidth. Its direct expression + # catastrophically cancels for x -> 0, so use the analytic series there: + # 3/x^2 (sin(x)/x - cos(x)) + # = 1 - x^2/10 + x^4/280 - x^6/15120 + O(x^8). + lag = np.arange(1, max_lag + 1, dtype=np.float64) + x = 6.0 * np.pi * lag / (5.0 * bandwidth) + small = np.abs(x) < 1.0e-3 + w = np.empty_like(x) + x2 = x[small] * x[small] + w[small] = 1.0 - x2 / 10.0 + x2 * x2 / 280.0 - x2 * x2 * x2 / 15120.0 + regular = ~small + xr = x[regular] + w[regular] = 3.0 / (xr * xr) * (np.sin(xr) / xr - np.cos(xr)) + weights[1:] = w + return canonical, weights + + +def driscoll_kraay_covariance( + X, + resid, + time_ids, + *, + bandwidth=None, + kernel="bartlett", + extra_df: int = 0, + xp=None, + metadata: Optional[dict] = None, +): + """Driscoll-Kraay covariance on fit-space influence scores.""" + xp = _ensure_xp(xp, X) + X = xp_asarray(X, dtype=xp.float64, xp=xp) + resid = xp_asarray(resid, dtype=xp.float64, xp=xp, ref_arr=X).ravel() + if X.ndim != 2 or resid.shape[0] != X.shape[0]: + raise ValueError("X and resid must have matching observation counts") + n = int(X.shape[0]) + labels, time_codes = _factorize_1d_labels( + time_ids, nobs=n, name="time_ids" + ) + n_periods = int(len(labels)) + if n_periods < 2: + raise ValueError( + "Driscoll-Kraay covariance requires at least two time periods" + ) + + if isinstance(extra_df, bool) or not isinstance(extra_df, (int, np.integer)): + raise ValueError("extra_df must be a non-negative integer") + extra_df = int(extra_df) + if extra_df < 0: + raise ValueError("extra_df must be a non-negative integer") + + influence, _X_pinv, _bread, rank = _influence_rows(X, resid, xp) + k_columns = int(X.shape[1]) + rank_deficient = rank < k_columns + df_model = rank if rank_deficient else k_columns + denom = n - extra_df - df_model + if denom <= 0: + raise ValueError( + "Driscoll-Kraay covariance requires positive debiased residual degrees of freedom" + ) + + grouped = _grouped_score_sums( + influence, time_codes, n_groups=n_periods, xp=xp + ) + bw = _validate_dk_bandwidth(bandwidth, n_periods) + canonical_kernel, weights_np = _dk_kernel_weights( + kernel, bw, n_periods - 1 + ) + weights = xp_asarray( + weights_np, + dtype=xp.float64, + xp=xp, + ref_arr=grouped, + ) + + cov = grouped.T @ grouped + for lag in range(1, n_periods): + if weights_np[lag] == 0.0: + continue + gamma = grouped[lag:].T @ grouped[: n_periods - lag] + cov = cov + weights[lag] * (gamma + gamma.T) + + scale = float(n) / float(denom) + cov = _symmetrize(scale * cov) + if metadata is not None: + nonzero_lags = np.flatnonzero(np.abs(weights_np[1:]) > 0.0) + 1 + metadata.update( + { + "covariance": "driscoll-kraay", + "kernel": canonical_kernel, + "bandwidth": int(bw), + "n_periods": n_periods, + "max_weighted_lag": int(nonzero_lags.max()) + if nonzero_lags.size + else 0, + "all_observed_lags_weighted": bool( + canonical_kernel == "qs" and bw > 0 + ), + "extra_df": int(extra_df), + "design_rank": int(rank), + "design_columns": int(k_columns), + "rank_deficient_extension": bool(rank_deficient), + "df_scale": float(scale), + } + ) + return cov + + +def _hc_covariance( + X, resid, *, kind: str, xp, metadata: Optional[dict] = None +): + influence, X_pinv, _bread, rank = _influence_rows(X, resid, xp) + if kind == "hc0": + if metadata is not None: + metadata.update( + { + "covariance": "hc0", + "design_rank": int(rank), + "design_columns": int(X.shape[1]), + } + ) + return _symmetrize(influence.T @ influence) + + projection_rows = X_pinv.T + if _is_torch(xp): + leverage = xp.sum(X * projection_rows, dim=1) + else: + leverage = xp.sum(X * projection_rows, axis=1) + leverage_min = _to_float_scalar(xp.min(leverage)) + leverage_max = _to_float_scalar(xp.max(leverage)) + tol = 4096.0 * np.finfo(np.float64).eps + if leverage_min < -tol: + raise ValueError("HC2/HC3 leverage is materially negative") + if leverage_max > 1.0 + tol: + raise ValueError("HC2/HC3 leverage is materially greater than one") + if _is_torch(xp): + leverage = xp.clamp(leverage, min=0.0, max=1.0) + else: + leverage = xp.clip(leverage, 0.0, 1.0) + denominator = 1.0 - leverage + denominator_min = _to_float_scalar(xp.min(denominator)) + if denominator_min <= tol: + raise ValueError( + "HC2/HC3 covariance is undefined when leverage is numerically one" + ) + if kind == "hc2": + adjusted_resid = resid / xp.sqrt(denominator) + elif kind == "hc3": + adjusted_resid = resid / denominator + else: + raise ValueError(f"unknown HC covariance kind {kind!r}") + adjusted_influence = projection_rows * adjusted_resid[:, None] + if metadata is not None: + metadata.update( + { + "covariance": kind, + "design_rank": int(rank), + "design_columns": int(X.shape[1]), + "leverage_min": float(leverage_min), + "leverage_max": float(leverage_max), + } + ) + return _symmetrize(adjusted_influence.T @ adjusted_influence) def ols_covariance( @@ -144,23 +532,30 @@ def ols_covariance( scale=None, df_resid=None, cluster=None, + time_ids=None, bandwidth=None, kernel="bartlett", + group_debias: bool = False, + extra_df: int = 0, xp=None, allowed=None, hc1_correction=None, + metadata: Optional[dict] = None, ): - """Dispatch existing residual-based panel covariance definitions. + """Dispatch residual-based panel covariance definitions.""" + xp = _ensure_xp(xp, X) + group_debias = _validate_group_debias(group_debias) + name = normalize_covariance_type(cov_type) + if allowed is not None: + allowed_names = {normalize_covariance_type(value) for value in allowed} + if name not in allowed_names: + choices = ", ".join(sorted(str(value) for value in allowed_names)) + raise ValueError( + f"cov_type={cov_type!r} is not supported here; expected one of: {choices}" + ) - This helper deliberately does not infer model-specific degrees of freedom. - Callers pass ``scale`` and ``df_resid`` (or an explicit HC1 correction) so - Stage A cannot silently harmonize distinct panel-model conventions. - """ - xp = _ensure_xp(xp) - name = str(cov_type).lower() - if allowed is not None and name not in {str(value).lower() for value in allowed}: - choices = ", ".join(sorted(str(value) for value in allowed)) - raise ValueError(f"cov_type={cov_type!r} is not supported here; expected one of: {choices}") + if group_debias and name != "clustered": + raise ValueError("group_debias=True requires cov_type='clustered'") X = xp_asarray(X, dtype=xp.float64, xp=xp) resid = xp_asarray(resid, dtype=xp.float64, xp=xp, ref_arr=X).ravel() @@ -168,30 +563,41 @@ def ols_covariance( raise ValueError("X and resid must have matching observation counts") n = int(X.shape[0]) + if metadata is not None: + metadata.clear() + metadata["covariance"] = name + if name == "nonrobust": if scale is None: raise ValueError("scale is required for nonrobust covariance") - XtX = X.T @ X - try: - bread = xp.linalg.inv(XtX) - except _LINALG_ERRORS: - bread = xp.linalg.pinv(XtX) - return float(scale) * bread + _X_pinv, bread, _rank = _design_pseudoinverse(X, xp) + return _symmetrize(float(scale) * bread) if name == "robust": - XtX = X.T @ X - try: - bread = xp.linalg.inv(XtX) - except _LINALG_ERRORS: - bread = xp.linalg.pinv(XtX) - scores = X * resid[:, None] - meat = scores.T @ scores + influence, _X_pinv, _bread, _rank = _influence_rows(X, resid, xp) correction = hc1_correction if correction is None: if df_resid is None or int(df_resid) <= 0: - raise ValueError("positive df_resid or hc1_correction is required for robust covariance") + raise ValueError( + "positive df_resid or hc1_correction is required for robust covariance" + ) correction = n / float(df_resid) - return bread @ meat @ bread * float(correction) + if metadata is not None: + metadata.update( + { + "covariance": "robust", + "hc_equivalent": "hc1", + "hc1_correction": float(correction), + } + ) + return _symmetrize( + influence.T @ influence * float(correction) + ) + + if name in {"hc0", "hc2", "hc3"}: + return _hc_covariance( + X, resid, kind=name, xp=xp, metadata=metadata + ) if name == "clustered": if cluster is None: @@ -199,21 +605,60 @@ def ols_covariance( cluster_np = np.asarray(_to_numpy(cluster)) if cluster_np.ndim == 2 and cluster_np.shape[1] == 2: return two_way_clustered_covariance( - X, resid, cluster_np[:, 0], cluster_np[:, 1], xp=xp + X, + resid, + cluster_np[:, 0], + cluster_np[:, 1], + xp=xp, + group_debias=group_debias, + metadata=metadata, ) - # Preserve the historical PanelOLS one-way behavior for a column-vector - # cluster array: clustered_covariance() ravelled an (n, 1) input. if cluster_np.ndim == 2 and cluster_np.shape[1] == 1: cluster_np = cluster_np[:, 0] if cluster_np.ndim != 1: - raise ValueError("cluster must be one-dimensional, (n, 1), or (n, 2)") - return clustered_covariance(X, resid, cluster_np, xp=xp) + raise ValueError( + "cluster must be one-dimensional, (n, 1), or (n, 2)" + ) + return clustered_covariance( + X, + resid, + cluster_np, + xp=xp, + group_debias=group_debias, + metadata=metadata, + ) if name == "hac": + if metadata is not None: + metadata.update( + { + "covariance": "hac", + "kernel": "bartlett", + "bandwidth": bandwidth, + "row_order_hac": True, + } + ) return hac_covariance( X, resid, bandwidth=bandwidth, kernel=kernel, xp=xp ) + if name == "driscoll-kraay": + if time_ids is None: + raise ValueError( + "time_ids is required for Driscoll-Kraay covariance" + ) + return driscoll_kraay_covariance( + X, + resid, + time_ids, + bandwidth=bandwidth, + kernel=kernel, + extra_df=extra_df, + xp=xp, + metadata=metadata, + ) + raise ValueError( - "cov_type must be one of 'nonrobust', 'robust', 'clustered', or 'hac'" + "cov_type must be one of 'nonrobust', 'robust', 'hc0', 'hc1', " + "'hc2', 'hc3', 'clustered', 'hac', or 'driscoll-kraay'" ) diff --git a/statgpu/panel/_diagnostics.py b/statgpu/panel/_diagnostics.py index f7b8191e8..28807dffb 100644 --- a/statgpu/panel/_diagnostics.py +++ b/statgpu/panel/_diagnostics.py @@ -815,6 +815,13 @@ def hausman_test(fe_model, re_model) -> PanelTestResult: distribution="chi2", reason="classical Hausman requires nonrobust FE covariance; robust auxiliary Hausman is not implemented in Stage B", ) + if str(getattr(re_model, "_cov_type", "nonrobust")).lower() != "nonrobust": + return _inapplicable( + null=null, + alternative=alternative, + distribution="chi2", + reason="classical Hausman requires nonrobust RE covariance; robust auxiliary Hausman is not implemented in Stage C", + ) left_id = getattr(fe_model, "_panel_diagnostic_identity", None) right_id = getattr(re_model, "_panel_diagnostic_identity", None) diff --git a/statgpu/panel/_first_diff.py b/statgpu/panel/_first_diff.py index f19c340c6..2c90311cf 100644 --- a/statgpu/panel/_first_diff.py +++ b/statgpu/panel/_first_diff.py @@ -17,9 +17,9 @@ class FirstDifferenceOLS(BasePanelModel): """First-difference OLS estimator for panel data. - Transforms the data by taking first differences within each entity: - ``Δy_t = y_t - y_{t-1}``, ``ΔX_t = X_t - X_{t-1}``, then runs OLS - on the differenced data. + Transforms the data by taking first differences within each entity and runs + OLS on the retained differenced sample. Stage C adds transformed-fit-space + HC0/HC2/HC3 covariance while preserving historical HC1 ``robust`` behavior. """ def __init__( @@ -30,16 +30,18 @@ def __init__( n_jobs: Optional[int] = None, ): super().__init__(device=device, n_jobs=n_jobs) - self.cov_type = cov_type.lower() + from statgpu.panel._covariance import normalize_covariance_type + + self.cov_type = normalize_covariance_type(cov_type) self.alpha = alpha - if self.cov_type not in ("nonrobust", "robust"): - raise ValueError("cov_type must be 'nonrobust' or 'robust'") + if self.cov_type not in ("nonrobust", "robust", "hc0", "hc2", "hc3"): + raise ValueError( + "cov_type must be one of 'nonrobust', 'robust', 'hc0', 'hc1', 'hc2', or 'hc3'" + ) 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.""" - # Preserve the existing contract: an explicit entity side array is - # required even when the numerical design is supplied by a formula. if entity_ids is None: raise ValueError("entity_ids is required for FirstDifferenceOLS") @@ -102,7 +104,7 @@ def fit(self, X=None, y=None, entity_ids=None, time_ids=None, formula=None, data df_resid=df_resid, backend=backend, cov_type=self._cov_type, - allowed=("nonrobust", "robust"), + allowed=("nonrobust", "robust", "hc0", "hc2", "hc3"), hc1_correction=n / df_resid if self._cov_type == "robust" else None, distribution_df=df_resid, diag_floor=1e-30, @@ -120,10 +122,6 @@ def fit(self, X=None, y=None, entity_ids=None, time_ids=None, formula=None, data 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, diff --git a/statgpu/panel/_fixed_effects.py b/statgpu/panel/_fixed_effects.py index 192b39d82..9b50742ca 100644 --- a/statgpu/panel/_fixed_effects.py +++ b/statgpu/panel/_fixed_effects.py @@ -1,8 +1,9 @@ """ Fixed effects panel data model (PanelOLS). -Implements one-way and two-way fixed effects estimation with support for the -existing non-robust, HC1 robust, and clustered covariance estimators. +Implements one-way and two-way fixed effects estimation with Stage-C covariance +support while preserving the historical nonrobust, HC1 robust, and clustered +contracts. """ from __future__ import annotations @@ -40,16 +41,37 @@ def __init__( alpha: float = 0.05, device: Union[str, Device] = Device.AUTO, n_jobs: Optional[int] = None, + *, + bandwidth: Optional[int] = None, + kernel: str = "bartlett", + group_debias: bool = False, ): super().__init__(device=device, n_jobs=n_jobs) + from statgpu.panel._covariance import normalize_covariance_type + self.entity_effects = entity_effects self.time_effects = time_effects - self.cov_type = cov_type.lower() + self.cov_type = normalize_covariance_type(cov_type) self.alpha = alpha - if self.cov_type not in ("nonrobust", "robust", "clustered"): + self.bandwidth = bandwidth + self.kernel = kernel + self.group_debias = group_debias + allowed = { + "nonrobust", + "robust", + "hc0", + "hc2", + "hc3", + "clustered", + "driscoll-kraay", + } + if self.cov_type not in allowed: raise ValueError( - "cov_type must be 'nonrobust', 'robust', or 'clustered'" + "cov_type must be one of 'nonrobust', 'robust', 'hc0', 'hc1', " + "'hc2', 'hc3', 'clustered', 'driscoll-kraay', 'dk', or 'kernel'" ) + if not isinstance(group_debias, (bool, np.bool_)): + raise ValueError("group_debias must be boolean") self.coef_ = None self.bse_ = None @@ -101,9 +123,6 @@ def fit( }, ) - # Preserve the existing formula contract: formula-extracted effects - # enable constructor flags, and formula identifiers fill only missing - # explicit side arrays. if fe_entity_effects: self.entity_effects = True if fe_time_effects: @@ -126,6 +145,10 @@ def fit( raise ValueError("time_ids is required when time_effects=True") if self._cov_type == "clustered" and cluster is None: raise ValueError("cluster is required when cov_type='clustered'") + if self._cov_type == "driscoll-kraay" and time_ids is None: + raise ValueError("time_ids is required for Driscoll-Kraay covariance") + if bool(self.group_debias) and self._cov_type != "clustered": + raise ValueError("group_debias=True requires cov_type='clustered'") self._panel_set_index_info( n, entity_ids=entity_ids, time_ids=time_ids @@ -181,10 +204,6 @@ def fit( 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, @@ -198,11 +217,6 @@ def fit( 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 @@ -231,10 +245,6 @@ def fit( scale = _to_float_scalar(xp.sum(resid ** 2)) / self.df_resid self._scale = scale - # Effect recovery remains model-specific and byte-for-byte equivalent in - # meaning to the pre-Stage-A implementation. The stored grand mean is - # intentionally not added by predict(); that historical behavior is - # frozen by test_panel_stage_a_golden.py. self._entity_effects_map = {} self._time_effects_map = {} resid_orig = y_arr - X_arr @ coef @@ -293,7 +303,20 @@ def fit( backend=backend, cov_type=self._cov_type, cluster=cluster_for_cov, - allowed=("nonrobust", "robust", "clustered"), + time_ids=time_ids, + bandwidth=self.bandwidth, + kernel=self.kernel, + group_debias=bool(self.group_debias), + extra_df=int(diagnostic_df["effect_rank"]), + allowed=( + "nonrobust", + "robust", + "hc0", + "hc2", + "hc3", + "clustered", + "driscoll-kraay", + ), hc1_correction=( n / self.df_resid if self._cov_type == "robust" else None ), @@ -301,16 +324,11 @@ 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 - # 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, 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, @@ -335,10 +353,6 @@ def fit( "legacy_rsquared_within": float(self.rsquared_within), }, ) - # 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) @@ -444,4 +458,4 @@ def set_params(self, **params): return super().set_params(**params) -FixedEffects = PanelOLS +FixedEffects = PanelOLS \ No newline at end of file diff --git a/statgpu/panel/_formula.py b/statgpu/panel/_formula.py index d9c3a93a9..523881906 100644 --- a/statgpu/panel/_formula.py +++ b/statgpu/panel/_formula.py @@ -306,26 +306,50 @@ def _prepare_formula_fit(formula, data, X, y, model_has_intercept=True, None, None, False, False) +def _ordered_categorical_array(values): + """Return an ordered categorical array-like without importing pandas.""" + candidate = getattr(values, "array", values) + dtype = getattr(candidate, "dtype", None) + if ( + getattr(dtype, "categories", None) is not None + and bool(getattr(dtype, "ordered", False)) + and getattr(candidate, "codes", None) is not None + ): + return candidate + return None + + def _align_formula_side_array(values, design_info, expected_n=None, name="array"): """Align an observation-level side array with rows retained by Patsy.""" if values is None: return None - arr = np.asarray(values) - if arr.ndim == 0: - raise ValueError(f"{name} must be observation-level") + + categorical = _ordered_categorical_array(values) + if categorical is None: + arr = np.asarray(values) + if arr.ndim == 0: + raise ValueError(f"{name} must be observation-level") + n_values = int(arr.shape[0]) + else: + arr = None + n_values = int(len(categorical)) + positions = getattr(design_info, "_statgpu_row_positions", None) if positions is None: - if expected_n is not None and arr.shape[0] != expected_n: + if expected_n is not None and n_values != expected_n: raise ValueError(f"{name} must have {expected_n} observations") - return arr + return categorical if categorical is not None else arr + positions = np.asarray(positions, dtype=np.int64) - if arr.shape[0] == positions.shape[0]: - return arr - if positions.size and arr.shape[0] > int(positions.max()): + if n_values == positions.shape[0]: + return categorical if categorical is not None else arr + if positions.size and n_values > int(positions.max()): + if categorical is not None: + return categorical.take(positions) return arr[positions] - if positions.size == 0 and arr.shape[0] == 0: - return arr - raise ValueError(f"{name} has {arr.shape[0]} observations and cannot be aligned to the {positions.shape[0]} rows retained by the formula") + if positions.size == 0 and n_values == 0: + return categorical if categorical is not None else arr + raise ValueError(f"{name} has {n_values} observations and cannot be aligned to the {positions.shape[0]} rows retained by the formula") def _formula_predict(X, design_info, formula_has_intercept, model_has_intercept): diff --git a/statgpu/panel/_pooled.py b/statgpu/panel/_pooled.py index 6fc137cb8..18a91114c 100644 --- a/statgpu/panel/_pooled.py +++ b/statgpu/panel/_pooled.py @@ -34,9 +34,9 @@ def _panel_lstsq(X, y, xp): class PooledOLS(BasePanelModel): """Pooled OLS estimator for panel data. - Runs OLS on the pooled (stacked) panel data without any demeaning - or transformation. Supports the existing nonrobust, HC1 robust, - clustered, and HAC covariance estimators. + Runs OLS on the pooled stacked panel. ``robust`` preserves the historical + HC1 contract, while Stage C adds HC0/HC2/HC3 and Driscoll-Kraay. ``hac`` + remains the legacy row-order Newey-West covariance. """ def __init__( @@ -47,16 +47,34 @@ def __init__( kernel: str = "bartlett", device: Union[str, Device] = Device.AUTO, n_jobs: Optional[int] = None, + *, + group_debias: bool = False, ): super().__init__(device=device, n_jobs=n_jobs) - self.cov_type = cov_type.lower() + from statgpu.panel._covariance import normalize_covariance_type + + self.cov_type = normalize_covariance_type(cov_type) self.alpha = alpha self.bandwidth = bandwidth self.kernel = kernel - if self.cov_type not in ("nonrobust", "robust", "clustered", "hac"): + self.group_debias = group_debias + allowed = { + "nonrobust", + "robust", + "hc0", + "hc2", + "hc3", + "clustered", + "hac", + "driscoll-kraay", + } + if self.cov_type not in allowed: raise ValueError( - "cov_type must be 'nonrobust', 'robust', 'clustered', or 'hac'" + "cov_type must be one of 'nonrobust', 'robust', 'hc0', 'hc1', " + "'hc2', 'hc3', 'clustered', 'hac', 'driscoll-kraay', 'dk', or 'kernel'" ) + if not isinstance(group_debias, (bool, np.bool_)): + raise ValueError("group_debias must be boolean") self.fit_statistics_ = None def fit( @@ -71,9 +89,10 @@ def fit( ): """Fit the pooled OLS model. - ``entity_ids`` is optional and does not affect coefficients. When + ``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. + Breusch-Pagan random-effects LM diagnostic. ``time_index`` supplies the + legacy row-HAC order and the Stage-C Driscoll-Kraay time grouping. """ ( y_data, @@ -98,6 +117,11 @@ def fit( cluster = aligned["cluster"] time_index = aligned["time_index"] entity_ids = aligned["entity_ids"] + if formula is not None and bool(self._formula_has_intercept): + self._feature_names = [ + "Intercept", + *list(self._feature_names or []), + ] backend, xp, X_arr, y_arr = self._panel_prepare_numeric(X_data, y_data) entity_arr = None @@ -110,10 +134,15 @@ def fit( 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. Stage B - # carries entity diagnostic codes through the identical permutation so - # BP/R² sufficient statistics cannot become misaligned with residuals. + if self._cov_type == "clustered" and cluster is None: + raise ValueError("cluster is required for cov_type='clustered'") + if self._cov_type == "driscoll-kraay" and time_index is None: + raise ValueError("time_index is required for Driscoll-Kraay covariance") + if bool(self.group_debias) and self._cov_type != "clustered": + raise ValueError("group_debias=True requires cov_type='clustered'") + + # Preserve the legacy HAC ordering exactly. Driscoll-Kraay deliberately + # does not use this row-order path: it aggregates scores by time label. 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]: @@ -145,17 +174,14 @@ def fit( cluster_for_cov = cluster if self._cov_type == "clustered": - if cluster is None: - raise ValueError("cluster is required for cov_type='clustered'") - # Preserve the existing validation/factorization behavior before - # delegating to the shared covariance registry. - cluster_for_cov, _ = factorize_panel_labels( - cluster, - xp, - ref_arr=X_arr, - name="cluster", - expected_n=n, - ) + cluster_np = np.asarray(_to_numpy(cluster)) + if cluster_np.ndim not in (1, 2) or cluster_np.shape[0] != n: + raise ValueError( + "cluster must have n_samples rows and one or two cluster dimensions" + ) + if cluster_np.ndim == 2 and cluster_np.shape[1] not in (1, 2): + raise ValueError("cluster must contain one or two cluster dimensions") + cluster_for_cov = cluster_np self._panel_store_ols_inference( X_arr, @@ -166,9 +192,21 @@ def fit( backend=backend, cov_type=self._cov_type, cluster=cluster_for_cov, + time_ids=time_index, bandwidth=self.bandwidth, kernel=self.kernel, - allowed=("nonrobust", "robust", "clustered", "hac"), + group_debias=bool(self.group_debias), + extra_df=0, + allowed=( + "nonrobust", + "robust", + "hc0", + "hc2", + "hc3", + "clustered", + "hac", + "driscoll-kraay", + ), hc1_correction=n / df_resid if self._cov_type == "robust" else None, distribution_df=df_resid, # PooledOLS historically used sqrt(diag(V)) without clipping. diff --git a/statgpu/panel/_random_effects.py b/statgpu/panel/_random_effects.py index e3ad27cf5..d4927c745 100644 --- a/statgpu/panel/_random_effects.py +++ b/statgpu/panel/_random_effects.py @@ -29,9 +29,9 @@ class RandomEffects(BasePanelModel): """Random effects estimator for panel data. - The Swamy-Arora variance-component and quasi-demeaning calculations remain - model-specific; Stage A only shares neutral lifecycle and nonrobust - inference infrastructure. + Swamy-Arora variance components and coefficients are covariance-invariant. + Stage C adds HC, clustered and Driscoll-Kraay inference on the quasi-demeaned + GLS fit space. """ def __init__( @@ -39,9 +39,40 @@ def __init__( alpha: float = 0.05, device: Union[str, Device] = Device.AUTO, n_jobs: Optional[int] = None, + *, + cov_type: str = "nonrobust", + bandwidth: Optional[int] = None, + kernel: str = "bartlett", + group_debias: bool = False, ): super().__init__(device=device, n_jobs=n_jobs) + from statgpu.panel._covariance import normalize_covariance_type + self.alpha = alpha + # Follow the repository constructor-capture contract used by the other + # panel estimators: expose the canonical value during __init__ so the + # wrapper stores it in _cov_type, then let the wrapper restore the exact + # raw public constructor argument after construction. + self.cov_type = normalize_covariance_type(cov_type) + self.bandwidth = bandwidth + self.kernel = kernel + self.group_debias = group_debias + allowed = { + "nonrobust", + "robust", + "hc0", + "hc2", + "hc3", + "clustered", + "driscoll-kraay", + } + if self.cov_type not in allowed: + raise ValueError( + "cov_type must be one of 'nonrobust', 'robust', 'hc0', 'hc1', " + "'hc2', 'hc3', 'clustered', 'driscoll-kraay', 'dk', or 'kernel'" + ) + if not isinstance(group_debias, (bool, np.bool_)): + raise ValueError("group_debias must be boolean") self.coef_ = None self.bse_ = None self.tvalues_ = None @@ -64,6 +95,7 @@ def fit( time_ids=None, formula=None, data=None, + cluster=None, ): """Fit the random effects model.""" ( @@ -81,22 +113,48 @@ def fit( y, model_has_intercept=False, support_pipe=True, - side_arrays={"entity_ids": entity_ids, "time_ids": time_ids}, + side_arrays={ + "entity_ids": entity_ids, + "time_ids": time_ids, + "cluster": cluster, + }, ) + + # The shared formula parser strips Patsy's Intercept because most panel + # estimators either add their own constant or transform it away. Random + # effects does neither. Restore the formula-generated constant here so + # standard R-style ``y ~ x | entity`` has its declared intercept, while + # ``0 +``/``- 1`` remains an explicit no-intercept model. + if formula is not None and bool(self._formula_has_intercept): + X_data = np.column_stack( + [ + np.ones(len(y_data), dtype=np.float64), + np.asarray(X_data, dtype=np.float64), + ] + ) + self._feature_names = [ + "Intercept", + *list(self._feature_names or []), + ] + entity_ids = aligned["entity_ids"] time_ids = aligned["time_ids"] + cluster = aligned["cluster"] if entity_ids is None and fe_entity_ids is not None: entity_ids = fe_entity_ids if time_ids is None and fe_time_ids is not None: time_ids = fe_time_ids if entity_ids is None: raise ValueError("entity_ids is required for RandomEffects") + if self._cov_type == "clustered" and cluster is None: + raise ValueError("cluster is required when cov_type='clustered'") + if self._cov_type == "driscoll-kraay" and time_ids is None: + raise ValueError("time_ids is required for Driscoll-Kraay covariance") + if bool(self.group_debias) and self._cov_type != "clustered": + raise ValueError("group_debias=True requires cov_type='clustered'") backend, xp, X_arr, y_arr = self._panel_prepare_numeric(X_data, y_data) - self._backend_name = backend.name - # Preserve the old validation order/message for entity_ids rather than - # letting the new metadata substrate introduce a different rejection. entity_arr, _entity_labels = factorize_panel_labels( entity_ids, xp, ref_arr=X_arr, name="entity_ids" ) @@ -106,30 +164,33 @@ def fit( raise ValueError( f"entity_ids has {entity_arr.shape[0]} observations but X has {n} rows" ) - # time_ids is currently reserved/unused by RandomEffects; do not add a - # new array-interface validation rule for it in this refactor. - self._panel_set_index_info(n, entity_ids=entity_ids) + # Preserve the Stage-B behavior for otherwise-unused time_ids. Only DK + # promotes time metadata into a validated model-index contract. + self._panel_set_index_info( + n, + entity_ids=entity_ids, + time_ids=time_ids if self._cov_type == "driscoll-kraay" else None, + ) 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. - self._panel_diagnostic_identity = build_diagnostic_identity( - X_arr, - y_arr, - xp=xp, - entity_codes=entity_arr, - feature_names=self._feature_names, - has_constant=has_constant, + self._panel_diagnostic_identity = ( + build_diagnostic_identity( + X_arr, + y_arr, + xp=xp, + entity_codes=entity_arr, + feature_names=self._feature_names, + has_constant=has_constant, + ) + if self._cov_type == "nonrobust" + else None ) # --- Step 1: Between estimation --- @@ -162,15 +223,6 @@ def fit( for j in range(k): X_within[:, j] = within_transform(X_arr[:, j], entity_arr, xp=xp) - # 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)], @@ -188,9 +240,6 @@ def fit( 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: @@ -278,9 +327,17 @@ def fit( self.df_resid = df_resid self._scale = _to_float_scalar(xp.sum(resid_gls ** 2)) / df_resid - # Existing RandomEffects inference is nonrobust OLS inference on the - # quasi-demeaned design. Reuse exactly that residual-sandwich context; - # robust RE covariance remains Stage C. + cluster_for_cov = cluster + if self._cov_type == "clustered": + cluster_np = np.asarray(_to_numpy(cluster)) + if cluster_np.ndim not in (1, 2) or cluster_np.shape[0] != n: + raise ValueError( + "cluster must have n_samples rows and one or two cluster dimensions" + ) + if cluster_np.ndim == 2 and cluster_np.shape[1] not in (1, 2): + raise ValueError("cluster must contain one or two cluster dimensions") + cluster_for_cov = cluster_np + self._panel_store_ols_inference( X_star, resid_gls, @@ -288,8 +345,23 @@ def fit( scale=self._scale, df_resid=df_resid, backend=backend, - cov_type="nonrobust", - allowed=("nonrobust",), + cov_type=self._cov_type, + cluster=cluster_for_cov, + time_ids=time_ids, + bandwidth=self.bandwidth, + kernel=self.kernel, + group_debias=bool(self.group_debias), + extra_df=0, + allowed=( + "nonrobust", + "robust", + "hc0", + "hc2", + "hc3", + "clustered", + "driscoll-kraay", + ), + hc1_correction=n / df_resid if self._cov_type == "robust" else None, distribution_df=df_resid, diag_floor=0.0, ) @@ -301,11 +373,6 @@ def fit( diagnostic_df_resid = n - rank_star ss_res_diag = _to_float_scalar(xp.sum(resid_gls * resid_gls)) - # 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: @@ -378,13 +445,19 @@ def predict(self, X): return X_arr @ self.coef_ def summary(self): - """Print and return the existing structured coefficient summary.""" + """Print and return the structured coefficient summary.""" k = len(self._params) + feature_names_override = ( + None + if self._feature_names is not None + else [f"x{i + 1}" for i in range(k)] + ) return self._panel_summary( model_type="RandomEffects", + cov_type=self._cov_type, variance_components=self.variance_components_, theta=self.theta_, - feature_names_override=[f"x{i + 1}" for i in range(k)], + feature_names_override=feature_names_override, print_result=True, ) diff --git a/statgpu/panel/_results.py b/statgpu/panel/_results.py index 302f88c5e..bc83e820d 100644 --- a/statgpu/panel/_results.py +++ b/statgpu/panel/_results.py @@ -12,7 +12,7 @@ import numpy as np -from statgpu.backends import _to_numpy +from statgpu.panel._utils import factorize_panel_metadata @dataclass(frozen=True) @@ -67,19 +67,14 @@ class PanelIndexInfo: def _factorize_metadata(values, name: str, nobs: int): if values is None: return None, None, None - # Entity/time identifiers are metadata and may safely be factorized on the - # host. Use the common backend conversion so CuPy/Torch CUDA labels do not - # rely on an invalid implicit ``np.asarray`` device transfer. - arr = np.asarray(_to_numpy(values)) - if arr.ndim != 1 or arr.size == 0: - raise ValueError(f"{name} must be a non-empty one-dimensional array") - if arr.shape[0] != nobs: - raise ValueError(f"{name} must have {nobs} observations") - try: - labels, codes = np.unique(arr, return_inverse=True) - except TypeError as exc: - raise ValueError(f"{name} must contain mutually comparable labels") from exc - counts = np.bincount(codes, minlength=len(labels)).astype(np.int64, copy=False) + labels, codes = factorize_panel_metadata( + values, + name=name, + expected_n=int(nobs), + ) + counts = np.bincount(codes, minlength=len(labels)).astype( + np.int64, copy=False + ) return codes.astype(np.int64, copy=False), labels, counts diff --git a/statgpu/panel/_utils.py b/statgpu/panel/_utils.py index 8d7d94cef..d31168e8f 100644 --- a/statgpu/panel/_utils.py +++ b/statgpu/panel/_utils.py @@ -20,6 +20,7 @@ "group_sizes", "make_group_dummies", "compute_panel_inference", + "factorize_panel_metadata", "factorize_panel_labels", "validate_panel_numeric_data", "validate_panel_alpha", @@ -32,7 +33,6 @@ from statgpu.backends import ( xp_asarray, - xp_copy, xp_maximum, xp_ones, xp_zeros, @@ -127,7 +127,12 @@ def __str__(self) -> str: ci_label = f"[{self.alpha/2:.3f}" if self.alpha != 0.05 else "[0.025" ci_label2 = f"{1-self.alpha/2:.3f}]" if self.alpha != 0.05 else "0.975]" lines.append("-" * 72) - lines.append(f"{'':<12} {'coef':>10} {'std err':>10} {'t':>8} {'P>|t|':>10} {ci_label:>10} {ci_label2:>10}") + statistic_label = "t" if self.cov_type in (None, "nonrobust") else "z" + pvalue_label = "P>|t|" if statistic_label == "t" else "P>|z|" + lines.append( + f"{'':<12} {'coef':>10} {'std err':>10} " + f"{statistic_label:>8} {pvalue_label:>10} {ci_label:>10} {ci_label2:>10}" + ) lines.append("-" * 72) for i, name in enumerate(self.feature_names): lines.append( @@ -141,63 +146,50 @@ def __str__(self) -> str: def to_dict(self) -> Dict: """Return a JSON-serializable dictionary.""" return { - 'model_type': self.model_type, - 'nobs': self.nobs, - 'df_resid': self.df_resid, - 'coef': self.coef.tolist(), - 'bse': self.bse.tolist(), - 'tvalues': self.tvalues.tolist(), - 'pvalues': self.pvalues.tolist(), - 'conf_int': self.conf_int.tolist(), - 'feature_names': self.feature_names, - 'rsquared_within': self.rsquared_within, - 'cov_type': self.cov_type, - 'entity_effects': self.entity_effects, - 'time_effects': self.time_effects, - 'variance_components': self.variance_components, - 'theta': self.theta, - 'alpha': self.alpha, + "model_type": self.model_type, + "nobs": self.nobs, + "df_resid": self.df_resid, + "coef": self.coef.tolist(), + "bse": self.bse.tolist(), + "tvalues": self.tvalues.tolist(), + "pvalues": self.pvalues.tolist(), + "conf_int": self.conf_int.tolist(), + "feature_names": self.feature_names, + "rsquared_within": self.rsquared_within, + "cov_type": self.cov_type, + "entity_effects": self.entity_effects, + "time_effects": self.time_effects, + "variance_components": self.variance_components, + "theta": self.theta, + "alpha": self.alpha, } def _scatter_add(xp, indices, values, n_groups): - """Scatter-add values into bins defined by indices. - - Returns an array ``out`` of shape ``(n_groups,)`` where - ``out[j] = sum(values[indices == j])``. - - Works across NumPy, CuPy, and PyTorch with a single kernel launch. - """ - if hasattr(xp, 'scatter_add'): - # PyTorch: scatter_add(dim, index, src) + """Scatter-add values into bins defined by indices on the selected backend.""" + backend_name = getattr(xp, "__name__", "") + if backend_name == "torch": out = xp.zeros(n_groups, dtype=values.dtype, device=values.device) out.scatter_add_(0, indices.long(), values) return out - elif hasattr(xp, 'add') and hasattr(xp, 'zeros') and xp.__name__ == 'cupy': - # CuPy: use cupyx.scatter_add or cp.add.at - try: - out = xp.zeros(n_groups, dtype=values.dtype) - from cupyx import scatter_add as _scatter_add_cu - _scatter_add_cu(out, indices, values) - return out - except ImportError: - # Fallback: compute on CPU then transfer back to GPU - out_np = np.zeros(n_groups, dtype=values.dtype) - np.add.at(out_np, _to_numpy(indices), _to_numpy(values)) - return xp.asarray(out_np) - else: - # NumPy: np.add.at - out = np.zeros(n_groups, dtype=values.dtype) - np.add.at(out, _to_numpy(indices), _to_numpy(values)) + if backend_name == "cupy": + # CuPy implements ``ufunc.at`` natively. Do not route numerical values + # through host NumPy when optional cupyx helpers are unavailable. + out = xp.zeros(n_groups, dtype=values.dtype) + xp.add.at(out, indices, values) return out + out = np.zeros(n_groups, dtype=values.dtype) + np.add.at( + out, + np.asarray(indices, dtype=np.int64), + np.asarray(values), + ) + return out -def _remap_to_contiguous(groups, xp): - """Remap group labels to contiguous 0..n_groups-1 indices. - Returns (indices, n_groups, unique_labels) where indices[i] is the - contiguous index of group groups[i]. - """ +def _remap_to_contiguous(groups, xp): + """Remap group labels to contiguous 0..n_groups-1 indices.""" groups_np = _to_numpy(groups).ravel() unique_labels, indices_np = np.unique(groups_np, return_inverse=True) n_groups = len(unique_labels) @@ -223,177 +215,165 @@ def validate_panel_numeric_data(X, y, xp): raise ValueError("X and y must contain only finite values") -def factorize_panel_labels(values, xp, ref_arr=None, name="labels", expected_n=None): - """Factorize observation-level labels on CPU and return device integer codes. +def _ordered_categorical_metadata(values, *, name: str, expected_n=None): + """Preserve declared pandas ordered-categorical chronology when present.""" + candidate = getattr(values, "array", values) + dtype = getattr(candidate, "dtype", None) + categories = getattr(dtype, "categories", None) + codes = getattr(candidate, "codes", None) + if categories is None or not bool(getattr(dtype, "ordered", False)) or codes is None: + return None - Labels are metadata, so categorical/string values are factorized once on the - host. Only compact int64 codes are copied to the numerical backend. + codes_np = np.asarray(codes, dtype=np.int64).ravel() + if codes_np.size == 0: + raise ValueError(f"{name} must be a non-empty one-dimensional array") + if expected_n is not None and codes_np.shape[0] != int(expected_n): + raise ValueError(f"{name} must have {int(expected_n)} observations") + if np.any(codes_np < 0): + raise ValueError(f"{name} must not contain missing or non-finite values") + + observed = np.unique(codes_np) + labels = np.asarray(categories)[observed] + remapped = np.searchsorted(observed, codes_np).astype(np.int64, copy=False) + return labels, remapped + + +def _object_label_is_missing(value) -> bool: + if value is None: + return True + if isinstance(value, (float, np.floating, complex, np.complexfloating)): + return not bool(np.isfinite(value)) + if isinstance(value, (np.datetime64, np.timedelta64)): + return bool(np.isnat(value)) + value_type = type(value) + if value_type.__module__.startswith("pandas") and value_type.__name__ in { + "NAType", + "NaTType", + }: + return True + return False + + +def factorize_panel_metadata(values, *, name="labels", expected_n=None): + """Validate and factorize observation metadata into CPU labels/codes. + + Entity, time and cluster labels share the same missing-value contract: + ``None``, NaN/Inf, NaT and pandas missing sentinels are rejected rather than + silently becoming legitimate panel groups. Ordered categoricals retain + their declared ordering. """ if values is None: return None, None + + categorical = _ordered_categorical_metadata( + values, name=name, expected_n=expected_n + ) + if categorical is not None: + return categorical + values_np = np.asarray(_to_numpy(values)) + if values_np.ndim == 2 and values_np.shape[1] == 1: + values_np = values_np[:, 0] if values_np.ndim != 1 or values_np.size == 0: raise ValueError(f"{name} must be a non-empty one-dimensional array") if expected_n is not None and values_np.shape[0] != int(expected_n): raise ValueError(f"{name} must have {int(expected_n)} observations") + + invalid = False + if np.issubdtype(values_np.dtype, np.number): + invalid = bool(np.any(~np.isfinite(values_np))) + elif np.issubdtype(values_np.dtype, np.datetime64) or np.issubdtype( + values_np.dtype, np.timedelta64 + ): + invalid = bool(np.any(np.isnat(values_np))) + elif values_np.dtype.kind == "O": + invalid = any(_object_label_is_missing(value) for value in values_np) + if invalid: + raise ValueError(f"{name} must not contain missing or non-finite values") + try: unique_labels, codes = np.unique(values_np, return_inverse=True) except TypeError as exc: - raise ValueError(f"{name} must contain mutually comparable labels") from exc + raise ValueError( + f"{name} must contain mutually comparable labels with deterministic identity" + ) from exc + return unique_labels, codes.astype(np.int64, copy=False) + + +def factorize_panel_labels(values, xp, ref_arr=None, name="labels", expected_n=None): + """Factorize validated metadata on CPU and copy only compact codes to device.""" + if values is None: + return None, None + unique_labels, codes = factorize_panel_metadata( + values, name=name, expected_n=expected_n + ) codes_dev = xp_asarray(codes, dtype=xp.int64, xp=xp, ref_arr=ref_arr) return codes_dev, unique_labels def within_transform(y, groups, xp=None): - """Remove group means (fixed-effect projection). - - Computes ``y_within[i] = y[i] - mean(y[groups == g[i]])`` for every - observation. Uses scatter-add for a single-kernel group reduction - instead of per-group Python loops. - - Parameters - ---------- - y : array-like, shape (n,) - Outcome vector. - groups : array-like, shape (n,) - Integer group labels. - xp : module, optional - Array module (numpy / cupy / torch). Defaults to numpy. - - Returns - ------- - y_within : array, shape (n,) - Demeaned outcome. - """ + """Remove group means (fixed-effect projection).""" if xp is None: xp = np y = xp_asarray(y, dtype=xp.float64, xp=xp).ravel() groups = xp_asarray(groups, xp=xp, ref_arr=y).ravel() - - # Remap groups to contiguous indices (single CPU sync for unique) idx, n_groups, _ = _remap_to_contiguous(groups, xp) - - # Group sums and counts via scatter-add (2 kernel launches total) group_sums = _scatter_add(xp, idx, y, n_groups) group_counts = _scatter_add(xp, idx, xp.ones_like(y), n_groups) - - # Group means (element-wise, no loop) group_means = group_sums / xp_maximum(group_counts, 1.0, xp) - - # Broadcast back: y_within = y - group_means[idx] return y - group_means[idx] def make_group_dummies(groups, xp=None): - """Create dummy variable matrix from group labels. - - Parameters - ---------- - groups : array-like, shape (n,) - Integer group labels. - xp : module, optional - Array module. Defaults to numpy. - - Returns - ------- - D : array, shape (n, n_groups) - Dummy matrix with ones indicating group membership. - """ + """Create dummy variable matrix from group labels.""" if xp is None: xp = np groups = xp_asarray(groups, xp=xp).ravel() n = len(groups) idx, n_groups, _ = _remap_to_contiguous(groups, xp) - - # Build dummy matrix using advanced indexing (no per-group loop) D = xp_zeros((n, n_groups), xp.float64, xp, groups) - if getattr(xp, '__name__', '') == 'torch': - row_idx = xp.arange(n, device=getattr(groups, 'device', None) - if hasattr(groups, 'device') else None) + if getattr(xp, "__name__", "") == "torch": + row_idx = xp.arange( + n, + device=getattr(groups, "device", None) + if hasattr(groups, "device") + else None, + ) else: row_idx = xp.arange(n) D[row_idx, idx] = 1.0 - return D def _within_transform_matrix(M, groups, xp): - """Remove group means from each column of matrix M (batched). - - Uses scatter-add on the full matrix to compute all column-group - means in one pass, instead of looping over columns. - - Parameters - ---------- - M : array, shape (n, k) - Input matrix. - groups : array, shape (n,) - Integer group labels. - xp : module - Array module. - - Returns - ------- - M_within : array, shape (n, k) - Column-demeaned matrix. - """ + """Remove group means from each column of matrix M (batched).""" n, k = M.shape idx, n_groups, _ = _remap_to_contiguous(groups, xp) - - # Compute group counts once (n_groups,) — reuse across all columns ones_col = xp_ones(n, M.dtype, xp, M) group_counts = _scatter_add(xp, idx, ones_col, n_groups) inv_counts = 1.0 / xp_maximum(group_counts, 1.0, xp) - # For each column, compute group sums and subtract - # This is still O(k) scatter-adds, but each operates on a full column - # which is much faster than per-group Python loops - result = M.copy() if hasattr(M, 'copy') else M.clone() + result = M.copy() if hasattr(M, "copy") else M.clone() for j in range(k): col = M[:, j] group_sums_j = _scatter_add(xp, idx, col, n_groups) group_means_j = group_sums_j * inv_counts result[:, j] = col - group_means_j[idx] - return result -def demean_variables(y, X, entity_ids, time_ids=None, xp=None, - max_iter=100, tol=1e-10): - """Demean *y* and *X* for fixed-effects estimation. - - If *time_ids* is also provided, performs two-way demeaning (entity - and time effects) using the alternating projection method (Mundlak - 1978). For balanced panels convergence occurs in one pass; for - unbalanced panels the iteration continues until the maximum change - across all variables is below *tol*. - - Parameters - ---------- - y : array-like, shape (n,) - Outcome vector. - X : array-like, shape (n, k) - Regressor matrix. - entity_ids : array-like, shape (n,) - Entity (individual) identifiers. - time_ids : array-like, shape (n,), optional - Time-period identifiers. If provided, two-way demeaning is applied. - xp : module, optional - Array module. Defaults to numpy. - max_iter : int, default=100 - Maximum alternating-projection iterations for two-way FE. - tol : float, default=1e-10 - Convergence tolerance for two-way FE (max absolute change). - - Returns - ------- - y_d : array, shape (n,) - Demeaned outcome. - X_d : array, shape (n, k) - Demeaned regressors. - """ +def demean_variables( + y, + X, + entity_ids, + time_ids=None, + xp=None, + max_iter=100, + tol=1e-10, +): + """Demean *y* and *X* for fixed-effects estimation.""" if xp is None: xp = np @@ -402,29 +382,26 @@ def demean_variables(y, X, entity_ids, time_ids=None, xp=None, X = X.reshape(-1, 1) y_d = xp_asarray(y, dtype=xp.float64, xp=xp).ravel() - X_d = X.copy() if hasattr(X, 'copy') else X.clone() if hasattr(X, 'clone') else X - 0.0 + X_d = ( + X.copy() + if hasattr(X, "copy") + else X.clone() + if hasattr(X, "clone") + else X - 0.0 + ) - # Entity demeaning (skip if entity_ids is None, e.g. time-only FE) if entity_ids is not None: y_d = within_transform(y_d, entity_ids, xp) X_d = _within_transform_matrix(X_d, entity_ids, xp) - # Time demeaning (two-way FE) with alternating projection - # Each iteration applies BOTH entity and time demeaning to ensure - # convergence to the true two-way fixed effects (Mundlak 1978). if time_ids is not None: - for iteration in range(max_iter): - y_d_old = y_d.copy() if hasattr(y_d, 'copy') else y_d.clone() - - # Alternate: entity demeaning then time demeaning - # Only apply entity demeaning if entity_ids is provided (two-way FE) + for _iteration in range(max_iter): + y_d_old = y_d.copy() if hasattr(y_d, "copy") else y_d.clone() if entity_ids is not None: y_d = within_transform(y_d, entity_ids, xp) X_d = _within_transform_matrix(X_d, entity_ids, xp) y_d = within_transform(y_d, time_ids, xp) X_d = _within_transform_matrix(X_d, time_ids, xp) - - # Check convergence (single sync) max_change = _to_float_scalar(xp.max(xp.abs(y_d - y_d_old))) if max_change < tol: break @@ -433,165 +410,77 @@ def demean_variables(y, X, entity_ids, time_ids=None, xp=None, def group_means(y, groups, xp=None): - """Compute group-level means aligned to each observation. - - Returns an array of shape (n,) where element *i* is the mean of *y* - over all observations belonging to the same group as observation *i*. - - Uses scatter-add for single-kernel group reduction. - - Parameters - ---------- - y : array-like, shape (n,) - Outcome vector. - groups : array-like, shape (n,) - Group labels. - xp : module, optional - Array module. Defaults to numpy. - - Returns - ------- - y_bar : array, shape (n,) - Group means aligned to each observation. - """ + """Compute group-level means aligned to each observation.""" if xp is None: xp = np y = xp_asarray(y, dtype=xp.float64, xp=xp).ravel() groups = xp_asarray(groups, xp=xp, ref_arr=y).ravel() - idx, n_groups, _ = _remap_to_contiguous(groups, xp) - - # Group sums and counts via scatter-add (2 kernel launches) group_sums = _scatter_add(xp, idx, y, n_groups) group_counts = _scatter_add(xp, idx, xp.ones_like(y), n_groups) - means = group_sums / xp_maximum(group_counts, 1.0, xp) return means[idx] def group_sizes(groups, xp=None): - """Return an array of per-observation group sizes. - - Element *i* is the number of observations in the group of - observation *i*. - - Uses scatter-add for single-kernel group counting. - - Parameters - ---------- - groups : array-like, shape (n,) - Group labels. - xp : module, optional - Array module. Defaults to numpy. - - Returns - ------- - T_i : array, shape (n,) - Group size for each observation. - """ + """Return an array of per-observation group sizes.""" if xp is None: xp = np groups = xp_asarray(groups, xp=xp).ravel() idx, n_groups, _ = _remap_to_contiguous(groups, xp) - - # Group counts via scatter-add (1 kernel launch) ones = xp_ones(len(groups), xp.float64, xp, groups) counts = _scatter_add(xp, idx, ones, n_groups) return counts[idx] def ols_inference_nonrobust(params, X, scale, df, alpha=0.05): - """Compute non-robust OLS inference (SE, t, p, CI). - - Parameters - ---------- - params : ndarray, shape (k,) - Estimated coefficients. - X : ndarray, shape (n, k) - Design matrix (numpy). - scale : float - Residual variance (RSS / df). - df : int - Residual degrees of freedom. - alpha : float - Significance level for confidence intervals. - - Returns - ------- - bse, tvalues, pvalues, conf_int : ndarrays - """ + """Compute non-robust OLS inference (SE, t, p, CI).""" from scipy import stats - XtX = X.T @ X - try: - XtX_inv = np.linalg.inv(XtX) - except np.linalg.LinAlgError: - XtX_inv = np.linalg.pinv(XtX) - - cov_params = scale * XtX_inv - bse = np.sqrt(np.diag(cov_params)) - _eps = np.finfo(np.float64).tiny - tvalues = params / np.maximum(bse, _eps) + X_pinv = np.linalg.pinv(X) + cov_params = scale * (X_pinv @ X_pinv.T) + diag = np.diag(cov_params) + tol = 4096.0 * np.finfo(np.float64).eps * max( + 1.0, float(np.max(np.abs(diag))) if diag.size else 1.0 + ) + if np.any(diag < -tol): + raise ValueError("covariance has materially negative diagonal variance") + bse = np.sqrt(np.maximum(diag, 0.0)) + tvalues = params / np.maximum(bse, np.finfo(np.float64).tiny) pvalues = 2 * (1 - stats.t.cdf(np.abs(tvalues), df)) t_crit = stats.t.ppf(1 - alpha / 2, df) - conf_int = np.column_stack([ - params - t_crit * bse, - params + t_crit * bse, - ]) + conf_int = np.column_stack( + [params - t_crit * bse, params + t_crit * bse] + ) return bse, tvalues, pvalues, conf_int -def compute_panel_inference(model, X, resid, params, scale, n, k, xp, backend_name, - cov_type, alpha, dist_df=None): - """Shared OLS inference for panel models. - - Computes standard errors, t-statistics, p-values, and confidence - intervals. Sets ``coef_``, ``bse_``, ``tvalues_``, ``pvalues_``, - and ``conf_int_`` on *model*. - - Parameters - ---------- - model : object - Model instance to receive fitted attributes. - X : array, shape (n, k) - Design matrix (on device). - resid : array, shape (n,) - Residuals (on device). - params : array, shape (k,) - Estimated coefficients (on device). - scale : float - Residual variance (sigma^2). - n : int - Number of observations. - k : int - Number of parameters. - xp : module - Array module. - backend_name : str - Backend name (``'numpy'``, ``'cupy'``, ``'torch'``). - cov_type : str - Covariance type: ``'nonrobust'``, ``'robust'``, ``'clustered'``, ``'hac'``. - alpha : float - Significance level for confidence intervals. - dist_df : int or None - Degrees of freedom for the t-distribution. Defaults to ``n - k``. - """ - from statgpu.backends import _LINALG_ERRORS, _to_numpy - - XtX = X.T @ X / n - try: - XtX_inv = xp.linalg.inv(XtX) - except _LINALG_ERRORS: - XtX_inv = xp.linalg.pinv(XtX) - +def compute_panel_inference( + model, + X, + resid, + params, + scale, + n, + k, + xp, + backend_name, + cov_type, + alpha, + dist_df=None, +): + """Legacy shared OLS inference, using an X-pseudoinverse stable bread.""" + from statgpu.backends import _to_numpy + + X_pinv = xp.linalg.pinv(X) + bread = X_pinv @ X_pinv.T if cov_type == "nonrobust": - cov_params = scale * XtX_inv / n + cov_params = scale * bread elif cov_type == "robust": - scores = X * resid[:, None] - meat = scores.T @ scores - cov_params = XtX_inv @ meat @ XtX_inv / (n * n) * n / (n - k) + influence = X_pinv.T * resid[:, None] + cov_params = influence.T @ influence * n / (n - k) elif cov_type == "clustered": raise ValueError( "cov_type='clustered' requires cluster labels. " @@ -603,16 +492,22 @@ def compute_panel_inference(model, X, resid, params, scale, n, k, xp, backend_na "Use PooledOLS or FamaMacBeth which have native HAC support." ) else: - cov_params = scale * XtX_inv / n + cov_params = scale * bread diag_cov = xp.diag(cov_params) - # Guard against zero/negative diagonal (ill-conditioned matrices) - diag_cov = xp_maximum(diag_cov, 1e-30, xp) + diag_abs_max = _to_float_scalar(xp.max(xp.abs(diag_cov))) + tol = 4096.0 * np.finfo(np.float64).eps * max(1.0, diag_abs_max) + if _to_float_scalar(xp.min(diag_cov)) < -tol: + raise ValueError("covariance has materially negative diagonal variance") + diag_cov = xp_maximum(diag_cov, 0.0, xp) bse_dev = xp.sqrt(diag_cov) - tvalues_dev = params / bse_dev + tvalues_dev = params / xp_maximum( + bse_dev, np.finfo(np.float64).tiny, xp + ) df = dist_df if dist_df is not None else n - k from statgpu.inference._distributions_backend import get_distribution + dist_name = "norm" if cov_type in ("robust", "clustered", "hac") else "t" t_dist = get_distribution(dist_name, backend=backend_name) if dist_name == "t": @@ -622,9 +517,7 @@ def compute_panel_inference(model, X, resid, params, scale, n, k, xp, backend_na pvalues_dev = 2 * t_dist.sf(xp.abs(tvalues_dev)) t_crit = t_dist.isf(alpha / 2) - # Ensure t_crit is on the same device as params (distribution may return CPU scalar). t_crit = xp_asarray(t_crit, dtype=params.dtype, xp=xp, ref_arr=params) - conf_low = params - t_crit * bse_dev conf_high = params + t_crit * bse_dev