-
Notifications
You must be signed in to change notification settings - Fork 4
Kuiper cleanup 2/n - Remove kuiper_distribution
#161
New issue
Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.
By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.
Already on GitHub? Sign in to your account
Closed
Closed
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
6c36a86 to
822aac8
Compare
flinder
added a commit
to flinder/MCGrad-1
that referenced
this pull request
Jan 23, 2026
Summary: Removes the public `kuiper_calibration` function and updates internal callers to use the new ECCE API or lower-level functions directly. ### Changes **Removed:** - `kuiper_calibration()` - wrapper function that computed Kuiper calibration distance **Refactored:** - `kuiper_test()` - now calls `ecce_sigma()` directly instead of `kuiper_calibration(..., normalization_method="kuiper_standard_deviation")` [Note: this function will be removed in a future commit] - `ecce()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` - `ecce_sigma()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` ### Rationale This is part of a cleanup series migrating from the legacy "kuiper" naming to the cleaner "ECCE" (Expected Cumulative Calibration Error) API. The `kuiper_calibration` function was just a thin wrapper that called `kuiper_calibration_per_segment().item()`, so callers now use that pattern directly. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Differential Revision: D91235674
flinder
added a commit
to flinder/MCGrad-1
that referenced
this pull request
Jan 23, 2026
Summary: Removes the public `kuiper_calibration` function and updates internal callers to use the new ECCE API or lower-level functions directly. ### Changes **Removed:** - `kuiper_calibration()` - wrapper function that computed Kuiper calibration distance **Refactored:** - `kuiper_test()` - now calls `ecce_sigma()` directly instead of `kuiper_calibration(..., normalization_method="kuiper_standard_deviation")` [Note: this function will be removed in a future commit] - `ecce()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` - `ecce_sigma()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` ### Rationale This is part of a cleanup series migrating from the legacy "kuiper" naming to the cleaner "ECCE" (Expected Cumulative Calibration Error) API. The `kuiper_calibration` function was just a thin wrapper that called `kuiper_calibration_per_segment().item()`, so callers now use that pattern directly. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Differential Revision: D91235674
flinder
added a commit
to flinder/MCGrad-1
that referenced
this pull request
Jan 26, 2026
Summary: Removes the public `kuiper_calibration` function and updates internal callers to use the new ECCE API or lower-level functions directly. ### Changes **Removed:** - `kuiper_calibration()` - wrapper function that computed Kuiper calibration distance **Refactored:** - `kuiper_test()` - now calls `ecce_sigma()` directly instead of `kuiper_calibration(..., normalization_method="kuiper_standard_deviation")` [Note: this function will be removed in a future commit] - `ecce()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` - `ecce_sigma()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` ### Rationale This is part of a cleanup series migrating from the legacy "kuiper" naming to the cleaner "ECCE" (Expected Cumulative Calibration Error) API. The `kuiper_calibration` function was just a thin wrapper that called `kuiper_calibration_per_segment().item()`, so callers now use that pattern directly. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Reviewed By: Lorenzo-Perini Differential Revision: D91235674
0509e1c to
1f813b1
Compare
flinder
added a commit
to flinder/MCGrad-1
that referenced
this pull request
Jan 26, 2026
Summary: Removes the public `kuiper_calibration` function and updates internal callers to use the new ECCE API or lower-level functions directly. ### Changes **Removed:** - `kuiper_calibration()` - wrapper function that computed Kuiper calibration distance **Refactored:** - `kuiper_test()` - now calls `ecce_sigma()` directly instead of `kuiper_calibration(..., normalization_method="kuiper_standard_deviation")` [Note: this function will be removed in a future commit] - `ecce()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` - `ecce_sigma()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` ### Rationale This is part of a cleanup series migrating from the legacy "kuiper" naming to the cleaner "ECCE" (Expected Cumulative Calibration Error) API. The `kuiper_calibration` function was just a thin wrapper that called `kuiper_calibration_per_segment().item()`, so callers now use that pattern directly. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Reviewed By: Lorenzo-Perini Differential Revision: D91235674
flinder
added a commit
to flinder/MCGrad-1
that referenced
this pull request
Jan 26, 2026
Summary: Removes the public `kuiper_calibration` function and updates internal callers to use the new ECCE API or lower-level functions directly. ### Changes **Removed:** - `kuiper_calibration()` - wrapper function that computed Kuiper calibration distance **Refactored:** - `kuiper_test()` - now calls `ecce_sigma()` directly instead of `kuiper_calibration(..., normalization_method="kuiper_standard_deviation")` [Note: this function will be removed in a future commit] - `ecce()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` - `ecce_sigma()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` ### Rationale This is part of a cleanup series migrating from the legacy "kuiper" naming to the cleaner "ECCE" (Expected Cumulative Calibration Error) API. The `kuiper_calibration` function was just a thin wrapper that called `kuiper_calibration_per_segment().item()`, so callers now use that pattern directly. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Reviewed By: Lorenzo-Perini Differential Revision: D91235674
flinder
added a commit
to flinder/MCGrad-1
that referenced
this pull request
Jan 26, 2026
Summary: Removes the public `kuiper_calibration` function and updates internal callers to use the new ECCE API or lower-level functions directly. ### Changes **Removed:** - `kuiper_calibration()` - wrapper function that computed Kuiper calibration distance **Refactored:** - `kuiper_test()` - now calls `ecce_sigma()` directly instead of `kuiper_calibration(..., normalization_method="kuiper_standard_deviation")` [Note: this function will be removed in a future commit] - `ecce()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` - `ecce_sigma()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` ### Rationale This is part of a cleanup series migrating from the legacy "kuiper" naming to the cleaner "ECCE" (Expected Cumulative Calibration Error) API. The `kuiper_calibration` function was just a thin wrapper that called `kuiper_calibration_per_segment().item()`, so callers now use that pattern directly. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Reviewed By: Lorenzo-Perini Differential Revision: D91235674
flinder
added a commit
to flinder/MCGrad-1
that referenced
this pull request
Jan 26, 2026
Summary: Removes the public `kuiper_calibration` function and updates internal callers to use the new ECCE API or lower-level functions directly. ### Changes **Removed:** - `kuiper_calibration()` - wrapper function that computed Kuiper calibration distance **Refactored:** - `kuiper_test()` - now calls `ecce_sigma()` directly instead of `kuiper_calibration(..., normalization_method="kuiper_standard_deviation")` [Note: this function will be removed in a future commit] - `ecce()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` - `ecce_sigma()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` ### Rationale This is part of a cleanup series migrating from the legacy "kuiper" naming to the cleaner "ECCE" (Expected Cumulative Calibration Error) API. The `kuiper_calibration` function was just a thin wrapper that called `kuiper_calibration_per_segment().item()`, so callers now use that pattern directly. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Reviewed By: Lorenzo-Perini Differential Revision: D91235674
flinder
added a commit
to flinder/MCGrad-1
that referenced
this pull request
Jan 26, 2026
Summary: Removes the public `kuiper_calibration` function and updates internal callers to use the new ECCE API or lower-level functions directly. ### Changes **Removed:** - `kuiper_calibration()` - wrapper function that computed Kuiper calibration distance **Refactored:** - `kuiper_test()` - now calls `ecce_sigma()` directly instead of `kuiper_calibration(..., normalization_method="kuiper_standard_deviation")` [Note: this function will be removed in a future commit] - `ecce()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` - `ecce_sigma()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` ### Rationale This is part of a cleanup series migrating from the legacy "kuiper" naming to the cleaner "ECCE" (Expected Cumulative Calibration Error) API. The `kuiper_calibration` function was just a thin wrapper that called `kuiper_calibration_per_segment().item()`, so callers now use that pattern directly. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Reviewed By: Lorenzo-Perini Differential Revision: D91235674
flinder
added a commit
to flinder/MCGrad-1
that referenced
this pull request
Jan 26, 2026
Summary: Removes the public `kuiper_calibration` function and updates internal callers to use the new ECCE API or lower-level functions directly. ### Changes **Removed:** - `kuiper_calibration()` - wrapper function that computed Kuiper calibration distance **Refactored:** - `kuiper_test()` - now calls `ecce_sigma()` directly instead of `kuiper_calibration(..., normalization_method="kuiper_standard_deviation")` [Note: this function will be removed in a future commit] - `ecce()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` - `ecce_sigma()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` ### Rationale This is part of a cleanup series migrating from the legacy "kuiper" naming to the cleaner "ECCE" (Expected Cumulative Calibration Error) API. The `kuiper_calibration` function was just a thin wrapper that called `kuiper_calibration_per_segment().item()`, so callers now use that pattern directly. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Reviewed By: Lorenzo-Perini Differential Revision: D91235674
flinder
added a commit
to flinder/MCGrad-1
that referenced
this pull request
Jan 26, 2026
Summary: Removes the public `kuiper_calibration` function and updates internal callers to use the new ECCE API or lower-level functions directly. ### Changes **Removed:** - `kuiper_calibration()` - wrapper function that computed Kuiper calibration distance **Refactored:** - `kuiper_test()` - now calls `ecce_sigma()` directly instead of `kuiper_calibration(..., normalization_method="kuiper_standard_deviation")` [Note: this function will be removed in a future commit] - `ecce()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` - `ecce_sigma()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` ### Rationale This is part of a cleanup series migrating from the legacy "kuiper" naming to the cleaner "ECCE" (Expected Cumulative Calibration Error) API. The `kuiper_calibration` function was just a thin wrapper that called `kuiper_calibration_per_segment().item()`, so callers now use that pattern directly. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Reviewed By: Lorenzo-Perini Differential Revision: D91235674
1f813b1 to
00e2212
Compare
flinder
added a commit
to flinder/MCGrad-1
that referenced
this pull request
Jan 26, 2026
Summary: Removes the public `kuiper_calibration` function and updates internal callers to use the new ECCE API or lower-level functions directly. ### Changes **Removed:** - `kuiper_calibration()` - wrapper function that computed Kuiper calibration distance **Refactored:** - `kuiper_test()` - now calls `ecce_sigma()` directly instead of `kuiper_calibration(..., normalization_method="kuiper_standard_deviation")` [Note: this function will be removed in a future commit] - `ecce()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` - `ecce_sigma()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` ### Rationale This is part of a cleanup series migrating from the legacy "kuiper" naming to the cleaner "ECCE" (Expected Cumulative Calibration Error) API. The `kuiper_calibration` function was just a thin wrapper that called `kuiper_calibration_per_segment().item()`, so callers now use that pattern directly. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Reviewed By: Lorenzo-Perini Differential Revision: D91235674
flinder
added a commit
to flinder/MCGrad-1
that referenced
this pull request
Jan 26, 2026
Summary: Removes the public `kuiper_calibration` function and updates internal callers to use the new ECCE API or lower-level functions directly. ### Changes **Removed:** - `kuiper_calibration()` - wrapper function that computed Kuiper calibration distance **Refactored:** - `kuiper_test()` - now calls `ecce_sigma()` directly instead of `kuiper_calibration(..., normalization_method="kuiper_standard_deviation")` [Note: this function will be removed in a future commit] - `ecce()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` - `ecce_sigma()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` ### Rationale This is part of a cleanup series migrating from the legacy "kuiper" naming to the cleaner "ECCE" (Expected Cumulative Calibration Error) API. The `kuiper_calibration` function was just a thin wrapper that called `kuiper_calibration_per_segment().item()`, so callers now use that pattern directly. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Reviewed By: Lorenzo-Perini Differential Revision: D91235674
flinder
added a commit
to flinder/MCGrad-1
that referenced
this pull request
Jan 26, 2026
Summary: Removes the public `kuiper_calibration` function and updates internal callers to use the new ECCE API or lower-level functions directly. ### Changes **Removed:** - `kuiper_calibration()` - wrapper function that computed Kuiper calibration distance **Refactored:** - `kuiper_test()` - now calls `ecce_sigma()` directly instead of `kuiper_calibration(..., normalization_method="kuiper_standard_deviation")` [Note: this function will be removed in a future commit] - `ecce()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` - `ecce_sigma()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` ### Rationale This is part of a cleanup series migrating from the legacy "kuiper" naming to the cleaner "ECCE" (Expected Cumulative Calibration Error) API. The `kuiper_calibration` function was just a thin wrapper that called `kuiper_calibration_per_segment().item()`, so callers now use that pattern directly. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Reviewed By: Lorenzo-Perini Differential Revision: D91235674
flinder
added a commit
to flinder/MCGrad-1
that referenced
this pull request
Jan 26, 2026
Summary: Removes the public `kuiper_calibration` function and updates internal callers to use the new ECCE API or lower-level functions directly. ### Changes **Removed:** - `kuiper_calibration()` - wrapper function that computed Kuiper calibration distance **Refactored:** - `kuiper_test()` - now calls `ecce_sigma()` directly instead of `kuiper_calibration(..., normalization_method="kuiper_standard_deviation")` [Note: this function will be removed in a future commit] - `ecce()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` - `ecce_sigma()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` ### Rationale This is part of a cleanup series migrating from the legacy "kuiper" naming to the cleaner "ECCE" (Expected Cumulative Calibration Error) API. The `kuiper_calibration` function was just a thin wrapper that called `kuiper_calibration_per_segment().item()`, so callers now use that pattern directly. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Reviewed By: Lorenzo-Perini Differential Revision: D91235674
flinder
added a commit
to flinder/MCGrad-1
that referenced
this pull request
Jan 26, 2026
Summary: Removes the public `kuiper_calibration` function and updates internal callers to use the new ECCE API or lower-level functions directly. ### Changes **Removed:** - `kuiper_calibration()` - wrapper function that computed Kuiper calibration distance **Refactored:** - `kuiper_test()` - now calls `ecce_sigma()` directly instead of `kuiper_calibration(..., normalization_method="kuiper_standard_deviation")` [Note: this function will be removed in a future commit] - `ecce()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` - `ecce_sigma()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` ### Rationale This is part of a cleanup series migrating from the legacy "kuiper" naming to the cleaner "ECCE" (Expected Cumulative Calibration Error) API. The `kuiper_calibration` function was just a thin wrapper that called `kuiper_calibration_per_segment().item()`, so callers now use that pattern directly. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Reviewed By: Lorenzo-Perini Differential Revision: D91235674
flinder
added a commit
to flinder/MCGrad-1
that referenced
this pull request
Jan 26, 2026
Summary: Removes the public `kuiper_calibration` function and updates internal callers to use the new ECCE API or lower-level functions directly. ### Changes **Removed:** - `kuiper_calibration()` - wrapper function that computed Kuiper calibration distance **Refactored:** - `kuiper_test()` - now calls `ecce_sigma()` directly instead of `kuiper_calibration(..., normalization_method="kuiper_standard_deviation")` [Note: this function will be removed in a future commit] - `ecce()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` - `ecce_sigma()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` ### Rationale This is part of a cleanup series migrating from the legacy "kuiper" naming to the cleaner "ECCE" (Expected Cumulative Calibration Error) API. The `kuiper_calibration` function was just a thin wrapper that called `kuiper_calibration_per_segment().item()`, so callers now use that pattern directly. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Reviewed By: Lorenzo-Perini Differential Revision: D91235674
flinder
added a commit
to flinder/MCGrad-1
that referenced
this pull request
Jan 26, 2026
Summary: Removes the public `kuiper_calibration` function and updates internal callers to use the new ECCE API or lower-level functions directly. ### Changes **Removed:** - `kuiper_calibration()` - wrapper function that computed Kuiper calibration distance **Refactored:** - `kuiper_test()` - now calls `ecce_sigma()` directly instead of `kuiper_calibration(..., normalization_method="kuiper_standard_deviation")` [Note: this function will be removed in a future commit] - `ecce()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` - `ecce_sigma()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` ### Rationale This is part of a cleanup series migrating from the legacy "kuiper" naming to the cleaner "ECCE" (Expected Cumulative Calibration Error) API. The `kuiper_calibration` function was just a thin wrapper that called `kuiper_calibration_per_segment().item()`, so callers now use that pattern directly. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Reviewed By: Lorenzo-Perini Differential Revision: D91235674
flinder
added a commit
to flinder/MCGrad-1
that referenced
this pull request
Jan 26, 2026
Summary: Removes the public `kuiper_calibration` function and updates internal callers to use the new ECCE API or lower-level functions directly. ### Changes **Removed:** - `kuiper_calibration()` - wrapper function that computed Kuiper calibration distance **Refactored:** - `kuiper_test()` - now calls `ecce_sigma()` directly instead of `kuiper_calibration(..., normalization_method="kuiper_standard_deviation")` [Note: this function will be removed in a future commit] - `ecce()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` - `ecce_sigma()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` ### Rationale This is part of a cleanup series migrating from the legacy "kuiper" naming to the cleaner "ECCE" (Expected Cumulative Calibration Error) API. The `kuiper_calibration` function was just a thin wrapper that called `kuiper_calibration_per_segment().item()`, so callers now use that pattern directly. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Reviewed By: Lorenzo-Perini Differential Revision: D91235674
flinder
added a commit
to flinder/MCGrad-1
that referenced
this pull request
Jan 26, 2026
Summary: Removes the public `kuiper_calibration` function and updates internal callers to use the new ECCE API or lower-level functions directly. ### Changes **Removed:** - `kuiper_calibration()` - wrapper function that computed Kuiper calibration distance **Refactored:** - `kuiper_test()` - now calls `ecce_sigma()` directly instead of `kuiper_calibration(..., normalization_method="kuiper_standard_deviation")` [Note: this function will be removed in a future commit] - `ecce()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` - `ecce_sigma()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` ### Rationale This is part of a cleanup series migrating from the legacy "kuiper" naming to the cleaner "ECCE" (Expected Cumulative Calibration Error) API. The `kuiper_calibration` function was just a thin wrapper that called `kuiper_calibration_per_segment().item()`, so callers now use that pattern directly. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Reviewed By: Lorenzo-Perini Differential Revision: D91235674
00e2212 to
ddd555d
Compare
flinder
added a commit
to flinder/MCGrad-1
that referenced
this pull request
Jan 26, 2026
Summary: Removes the public `kuiper_calibration` function and updates internal callers to use the new ECCE API or lower-level functions directly. ### Changes **Removed:** - `kuiper_calibration()` - wrapper function that computed Kuiper calibration distance **Refactored:** - `kuiper_test()` - now calls `ecce_sigma()` directly instead of `kuiper_calibration(..., normalization_method="kuiper_standard_deviation")` [Note: this function will be removed in a future commit] - `ecce()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` - `ecce_sigma()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` ### Rationale This is part of a cleanup series migrating from the legacy "kuiper" naming to the cleaner "ECCE" (Expected Cumulative Calibration Error) API. The `kuiper_calibration` function was just a thin wrapper that called `kuiper_calibration_per_segment().item()`, so callers now use that pattern directly. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Reviewed By: Lorenzo-Perini Differential Revision: D91235674
flinder
added a commit
to flinder/MCGrad-1
that referenced
this pull request
Jan 26, 2026
Summary: Removes the public `kuiper_calibration` function and updates internal callers to use the new ECCE API or lower-level functions directly. ### Changes **Removed:** - `kuiper_calibration()` - wrapper function that computed Kuiper calibration distance **Refactored:** - `kuiper_test()` - now calls `ecce_sigma()` directly instead of `kuiper_calibration(..., normalization_method="kuiper_standard_deviation")` [Note: this function will be removed in a future commit] - `ecce()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` - `ecce_sigma()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` ### Rationale This is part of a cleanup series migrating from the legacy "kuiper" naming to the cleaner "ECCE" (Expected Cumulative Calibration Error) API. The `kuiper_calibration` function was just a thin wrapper that called `kuiper_calibration_per_segment().item()`, so callers now use that pattern directly. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Reviewed By: Lorenzo-Perini Differential Revision: D91235674
flinder
added a commit
to flinder/MCGrad-1
that referenced
this pull request
Jan 26, 2026
Summary: Removes the public `kuiper_calibration` function and updates internal callers to use the new ECCE API or lower-level functions directly. ### Changes **Removed:** - `kuiper_calibration()` - wrapper function that computed Kuiper calibration distance **Refactored:** - `kuiper_test()` - now calls `ecce_sigma()` directly instead of `kuiper_calibration(..., normalization_method="kuiper_standard_deviation")` [Note: this function will be removed in a future commit] - `ecce()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` - `ecce_sigma()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` ### Rationale This is part of a cleanup series migrating from the legacy "kuiper" naming to the cleaner "ECCE" (Expected Cumulative Calibration Error) API. The `kuiper_calibration` function was just a thin wrapper that called `kuiper_calibration_per_segment().item()`, so callers now use that pattern directly. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Reviewed By: Lorenzo-Perini Differential Revision: D91235674
…lue (facebookincubator#160) Summary: Introduces a cleaner public API for Expected Cumulative Calibration Error (ECCE) metrics. The new ecce(), ecce_sigma(), and ecce_pvalue() functions provide simplified interfaces to the existing kuiper calibration functionality, making the API more intuitive for users who want to compute calibration errors without needing to understand the underlying Kuiper test implementation details. Deprecation of old versions of the functions will come in follow up diffs. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Reviewed By: TaXxER Differential Revision: D91235672
Summary: Removes the public `kuiper_calibration` function and updates internal callers to use the new ECCE API or lower-level functions directly. ### Changes **Removed:** - `kuiper_calibration()` - wrapper function that computed Kuiper calibration distance **Refactored:** - `kuiper_test()` - now calls `ecce_sigma()` directly instead of `kuiper_calibration(..., normalization_method="kuiper_standard_deviation")` [Note: this function will be removed in a future commit] - `ecce()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` - `ecce_sigma()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` ### Rationale This is part of a cleanup series migrating from the legacy "kuiper" naming to the cleaner "ECCE" (Expected Cumulative Calibration Error) API. The `kuiper_calibration` function was just a thin wrapper that called `kuiper_calibration_per_segment().item()`, so callers now use that pattern directly. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Reviewed By: Lorenzo-Perini Differential Revision: D91235674
flinder
added a commit
to flinder/MCGrad-1
that referenced
this pull request
Jan 26, 2026
Summary: Removes the public `kuiper_calibration` function and updates internal callers to use the new ECCE API or lower-level functions directly. ### Changes **Removed:** - `kuiper_calibration()` - wrapper function that computed Kuiper calibration distance **Refactored:** - `kuiper_test()` - now calls `ecce_sigma()` directly instead of `kuiper_calibration(..., normalization_method="kuiper_standard_deviation")` [Note: this function will be removed in a future commit] - `ecce()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` - `ecce_sigma()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` ### Rationale This is part of a cleanup series migrating from the legacy "kuiper" naming to the cleaner "ECCE" (Expected Cumulative Calibration Error) API. The `kuiper_calibration` function was just a thin wrapper that called `kuiper_calibration_per_segment().item()`, so callers now use that pattern directly. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Reviewed By: Lorenzo-Perini Differential Revision: D91235674
ddd555d to
dbe8156
Compare
flinder
added a commit
to flinder/MCGrad-1
that referenced
this pull request
Jan 26, 2026
Summary: Removes the public `kuiper_calibration` function and updates internal callers to use the new ECCE API or lower-level functions directly. ### Changes **Removed:** - `kuiper_calibration()` - wrapper function that computed Kuiper calibration distance **Refactored:** - `kuiper_test()` - now calls `ecce_sigma()` directly instead of `kuiper_calibration(..., normalization_method="kuiper_standard_deviation")` [Note: this function will be removed in a future commit] - `ecce()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` - `ecce_sigma()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` ### Rationale This is part of a cleanup series migrating from the legacy "kuiper" naming to the cleaner "ECCE" (Expected Cumulative Calibration Error) API. The `kuiper_calibration` function was just a thin wrapper that called `kuiper_calibration_per_segment().item()`, so callers now use that pattern directly. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Reviewed By: Lorenzo-Perini Differential Revision: D91235674
flinder
added a commit
to flinder/MCGrad-1
that referenced
this pull request
Jan 26, 2026
Summary: Removes the public `kuiper_calibration` function and updates internal callers to use the new ECCE API or lower-level functions directly. ### Changes **Removed:** - `kuiper_calibration()` - wrapper function that computed Kuiper calibration distance **Refactored:** - `kuiper_test()` - now calls `ecce_sigma()` directly instead of `kuiper_calibration(..., normalization_method="kuiper_standard_deviation")` [Note: this function will be removed in a future commit] - `ecce()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` - `ecce_sigma()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` ### Rationale This is part of a cleanup series migrating from the legacy "kuiper" naming to the cleaner "ECCE" (Expected Cumulative Calibration Error) API. The `kuiper_calibration` function was just a thin wrapper that called `kuiper_calibration_per_segment().item()`, so callers now use that pattern directly. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Reviewed By: Lorenzo-Perini Differential Revision: D91235674
flinder
added a commit
to flinder/MCGrad-1
that referenced
this pull request
Jan 26, 2026
Summary: Removes the public `kuiper_calibration` function and updates internal callers to use the new ECCE API or lower-level functions directly. ### Changes **Removed:** - `kuiper_calibration()` - wrapper function that computed Kuiper calibration distance **Refactored:** - `kuiper_test()` - now calls `ecce_sigma()` directly instead of `kuiper_calibration(..., normalization_method="kuiper_standard_deviation")` [Note: this function will be removed in a future commit] - `ecce()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` - `ecce_sigma()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` ### Rationale This is part of a cleanup series migrating from the legacy "kuiper" naming to the cleaner "ECCE" (Expected Cumulative Calibration Error) API. The `kuiper_calibration` function was just a thin wrapper that called `kuiper_calibration_per_segment().item()`, so callers now use that pattern directly. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Reviewed By: Lorenzo-Perini Differential Revision: D91235674
flinder
added a commit
to flinder/MCGrad-1
that referenced
this pull request
Jan 26, 2026
Summary: Removes the public `kuiper_calibration` function and updates internal callers to use the new ECCE API or lower-level functions directly. ### Changes **Removed:** - `kuiper_calibration()` - wrapper function that computed Kuiper calibration distance **Refactored:** - `kuiper_test()` - now calls `ecce_sigma()` directly instead of `kuiper_calibration(..., normalization_method="kuiper_standard_deviation")` [Note: this function will be removed in a future commit] - `ecce()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` - `ecce_sigma()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` ### Rationale This is part of a cleanup series migrating from the legacy "kuiper" naming to the cleaner "ECCE" (Expected Cumulative Calibration Error) API. The `kuiper_calibration` function was just a thin wrapper that called `kuiper_calibration_per_segment().item()`, so callers now use that pattern directly. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Reviewed By: Lorenzo-Perini Differential Revision: D91235674
flinder
added a commit
to flinder/MCGrad-1
that referenced
this pull request
Jan 26, 2026
Summary: Removes the public `kuiper_calibration` function and updates internal callers to use the new ECCE API or lower-level functions directly. ### Changes **Removed:** - `kuiper_calibration()` - wrapper function that computed Kuiper calibration distance **Refactored:** - `kuiper_test()` - now calls `ecce_sigma()` directly instead of `kuiper_calibration(..., normalization_method="kuiper_standard_deviation")` [Note: this function will be removed in a future commit] - `ecce()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` - `ecce_sigma()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` ### Rationale This is part of a cleanup series migrating from the legacy "kuiper" naming to the cleaner "ECCE" (Expected Cumulative Calibration Error) API. The `kuiper_calibration` function was just a thin wrapper that called `kuiper_calibration_per_segment().item()`, so callers now use that pattern directly. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Reviewed By: Lorenzo-Perini Differential Revision: D91235674
flinder
added a commit
to flinder/MCGrad-1
that referenced
this pull request
Jan 26, 2026
Summary: Removes the public `kuiper_calibration` function and updates internal callers to use the new ECCE API or lower-level functions directly. ### Changes **Removed:** - `kuiper_calibration()` - wrapper function that computed Kuiper calibration distance **Refactored:** - `kuiper_test()` - now calls `ecce_sigma()` directly instead of `kuiper_calibration(..., normalization_method="kuiper_standard_deviation")` [Note: this function will be removed in a future commit] - `ecce()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` - `ecce_sigma()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` ### Rationale This is part of a cleanup series migrating from the legacy "kuiper" naming to the cleaner "ECCE" (Expected Cumulative Calibration Error) API. The `kuiper_calibration` function was just a thin wrapper that called `kuiper_calibration_per_segment().item()`, so callers now use that pattern directly. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Reviewed By: Lorenzo-Perini Differential Revision: D91235674
flinder
added a commit
to flinder/MCGrad-1
that referenced
this pull request
Jan 26, 2026
Summary: Removes the public `kuiper_calibration` function and updates internal callers to use the new ECCE API or lower-level functions directly. ### Changes **Removed:** - `kuiper_calibration()` - wrapper function that computed Kuiper calibration distance **Refactored:** - `kuiper_test()` - now calls `ecce_sigma()` directly instead of `kuiper_calibration(..., normalization_method="kuiper_standard_deviation")` [Note: this function will be removed in a future commit] - `ecce()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` - `ecce_sigma()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` ### Rationale This is part of a cleanup series migrating from the legacy "kuiper" naming to the cleaner "ECCE" (Expected Cumulative Calibration Error) API. The `kuiper_calibration` function was just a thin wrapper that called `kuiper_calibration_per_segment().item()`, so callers now use that pattern directly. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Reviewed By: Lorenzo-Perini Differential Revision: D91235674
flinder
added a commit
to flinder/MCGrad-1
that referenced
this pull request
Jan 26, 2026
Summary: Removes the public `kuiper_calibration` function and updates internal callers to use the new ECCE API or lower-level functions directly. ### Changes **Removed:** - `kuiper_calibration()` - wrapper function that computed Kuiper calibration distance **Refactored:** - `kuiper_test()` - now calls `ecce_sigma()` directly instead of `kuiper_calibration(..., normalization_method="kuiper_standard_deviation")` [Note: this function will be removed in a future commit] - `ecce()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` - `ecce_sigma()` - now calls `kuiper_calibration_per_segment(...).item()` directly instead of going through `kuiper_calibration()` ### Rationale This is part of a cleanup series migrating from the legacy "kuiper" naming to the cleaner "ECCE" (Expected Cumulative Calibration Error) API. The `kuiper_calibration` function was just a thin wrapper that called `kuiper_calibration_per_segment().item()`, so callers now use that pattern directly. ------------------------------------- Target API design ------------------------------------- ``` ┌─────────────────────────────────────────────────────────────────────────────────┐ │ ECCE API ARCHITECTURE │ ├─────────────────────────────────────────────────────────────────────────────────┤ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ PUBLIC API (User-Facing) ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ ┌─────────────┐ ┌──────────────┐ ┌──────────────────────────┐ ║ │ │ ║ │ ecce() │ │ ecce_sigma() │ │ ecce_pvalue() │ ║ │ │ ║ │ │ │ │ │ │ ║ │ │ ║ │ Unnormalized│ │ Normalized │ │ P-value for │ ║ │ │ ║ │ calibration │───▶│ by std dev │───▶│ calibration test │ ║ │ │ ║ │ error │ │ (sigma) │ │ │ ║ │ │ ║ └──────┬──────┘ └──────┬───────┘ └────────────┬─────────────┘ ║ │ │ ║ │ │ │ ║ │ │ ╚══════════╪══════════════════╪═════════════════════════╪══════════════════╝ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌──────────────────────────┐ │ │ │ │ │ ecce_pvalue_from_sigma()│ │ │ │ │ │ (public helper) │ │ │ │ │ └────────────┬─────────────┘ │ │ │ │ │ │ │ ┌──────────┴──────────────────┴────────────────────────┴───────────────────┐ │ │ │ PRIVATE HELPERS │ │ │ ├──────────────────────────────────────────────────────────────────────────┤ │ │ │ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _calculate_cumulative_ │ │ _ecce_cdf() │ │ │ │ │ │ differences() │ │ │ │ │ │ │ │ │ │ CDF for Brownian motion │ │ │ │ │ │ Core computation of weighted │ │ range (for p-value calc) │ │ │ │ │ │ cumulative differences │ │ │ │ │ │ │ └───────────────┬────────────────┘ └─────────────────────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────────────────┐ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_per_segment() │ │ _ecce_standard_deviation() │ │ │ │ │ │ │ │ │ │ │ │ │ │ Vectorized ECCE computation │ │ Wrapper → calls per_segment│ │ │ │ │ │ for multiple segments │ │ version with .item() │ │ │ │ │ └────────────────────────────────┘ └──────────────┬──────────────┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌─────────────────────────────┐ │ │ │ │ │ _ecce_standard_deviation_ │ │ │ │ │ │ per_segment() │ │ │ │ │ │ │ │ │ │ │ │ Variance-based std dev │ │ │ │ │ │ for multiple segments │ │ │ │ │ └─────────────────────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────────────────────┘ │ │ │ │ ╔═══════════════════════════════════════════════════════════════════════════╗ │ │ ║ MulticalibrationError Class ║ │ │ ╠═══════════════════════════════════════════════════════════════════════════╣ │ │ ║ ║ │ │ ║ Computes calibration metrics across multiple data segments ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Cached Properties │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_ecces_absolute ──────────▶ _ecce_per_segment() │ ║ │ │ ║ │ (ECCE per segment) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_sigmas ──────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (std dev per segment) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ sigma_0 ─────────────────────────▶ _ecce_standard_deviation_ │ ║ │ │ ║ │ (global std dev) per_segment() │ ║ │ │ ║ │ │ ║ │ │ ║ │ p_value ─────────────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (min p-value across segments) │ ║ │ │ ║ │ │ ║ │ │ ║ │ segment_p_values ────────────────▶ ecce_pvalue_from_sigma() │ ║ │ │ ║ │ (p-value per segment) (vectorized) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ║ ┌─────────────────────────────────────────────────────────────────────┐ ║ │ │ ║ │ Derived Metrics │ ║ │ │ ║ ├─────────────────────────────────────────────────────────────────────┤ ║ │ │ ║ │ │ ║ │ │ ║ │ mce = max(segment_ecces_absolute) │ ║ │ │ ║ │ mce_sigma_scale = max(segment_ecces_absolute / segment_sigmas) │ ║ │ │ ║ │ mce_relative = mce / ecce_0 (normalized by global ECCE) │ ║ │ │ ║ │ │ ║ │ │ ║ └─────────────────────────────────────────────────────────────────────┘ ║ │ │ ║ ║ │ │ ╚═══════════════════════════════════════════════════════════════════════════╝ │ │ │ └─────────────────────────────────────────────────────────────────────────────────┘ ``` Reviewed By: Lorenzo-Perini Differential Revision: D91235674
|
This pull request has been merged in cdfeef6. |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Labels
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Summary:
Remove the function kuiper_distribution and replace with
eccefor usage withnormalization_method=Noneandecce_sigmafor usage withnormalization_method="kuiper_standard_deviation"refactor all internal and external callsites to use the new API
Differential Revision: D91235674