eb-optimization 0.1.0__py3-none-any.whl

eb_optimization/tuning/tau.py

@@ -0,0 +1,510 @@
+from __future__ import annotations
+
+r"""
+Data-driven tolerance (τ) selection utilities for HR@τ.
+
+This module provides deterministic, residual-only methods for selecting the tolerance
+parameter τ used by the hit-rate metric HR@τ (hit rate within an absolute-error band).
+
+The hit-rate metric is:
+
+$$
+\mathrm{HR}@\tau = \frac{1}{n}\sum_{i=1}^{n}\mathbf{1}\left(|y_i-\hat{y}_i|\le \tau\right)
+$$
+
+Here, τ defines an *acceptability band*: the maximum absolute error considered operationally
+acceptable.
+
+Design notes
+------------
+- τ is estimated from historical residuals only (no exogenous data, no model assumptions).
+- The module supports global τ estimation and entity-level τ estimation.
+- Optional governance controls allow capping entity τ values by a global cap to prevent
+  tolerance inflation.
+
+Methods
+-------
+The global estimator supports three selection modes:
+
+1. ``"target_hit_rate"``:
+   choose τ such that a target fraction of residual magnitudes is covered:
+
+   $$
+   \tau = Q_h\left(|e|\right), \quad e_i = y_i-\hat{y}_i
+   $$
+
+   where $Q_h(\cdot)$ is the quantile function at level $h$.
+
+2. ``"knee"``:
+   select τ at a diminishing-returns point on the monotone curve $\mathrm{HR}@\tau$.
+
+3. ``"utility"``:
+   maximize a simple tradeoff between coverage and tolerance width:
+
+   $$
+   \tau^\* = \arg\max_{\tau \in \mathcal{T}}
+   \left[\mathrm{HR}@\tau - \lambda\left(\frac{\tau}{\tau_{\max}}\right)\right]
+   $$
+
+The entity-level estimator runs the same procedure per entity, optionally capping each
+entity τ by a global cap derived from the full residual distribution.
+"""
+
+from dataclasses import dataclass
+from typing import Any, Dict, Iterable, Literal, Mapping, Optional, Tuple, Union
+
+import numpy as np
+import pandas as pd
+
+# Single source of truth for the HR@τ metric math
+from eb_metrics.metrics.service import hr_at_tau as _hr_at_tau_core
+
+TauMethod = Literal["target_hit_rate", "knee", "utility"]
+
+
+def _to_1d_float_array(x: Union[pd.Series, np.ndarray, Iterable[float]]) -> np.ndarray:
+    """Convert input to a 1D float NumPy array."""
+    return np.asarray(x, dtype=float).reshape(-1)
+
+
+def _nan_safe_abs_errors(
+    y: Union[pd.Series, np.ndarray, Iterable[float]],
+    yhat: Union[pd.Series, np.ndarray, Iterable[float]],
+) -> np.ndarray:
+    r"""
+    Compute absolute errors with NaN/inf filtering.
+
+    Non-finite (y, yhat) pairs are dropped. The returned array contains:
+
+    $$
+    |e_i| = |y_i - \hat{y}_i|
+    $$
+
+    for finite pairs only.
+    """
+    y_arr = _to_1d_float_array(y)
+    yhat_arr = _to_1d_float_array(yhat)
+    if y_arr.shape[0] != yhat_arr.shape[0]:
+        raise ValueError(
+            f"y and yhat must have the same length. Got {len(y_arr)} vs {len(yhat_arr)}."
+        )
+    mask = np.isfinite(y_arr) & np.isfinite(yhat_arr)
+    return np.abs(y_arr[mask] - yhat_arr[mask])
+
+
+def _validate_tau(tau: float) -> float:
+    """Validate τ as finite and non-negative."""
+    if not np.isfinite(tau):
+        raise ValueError(f"tau must be finite. Got {tau}.")
+    if tau < 0:
+        raise ValueError(f"tau must be >= 0. Got {tau}.")
+    return float(tau)
+
+
+def _quantile(x: np.ndarray, q: float) -> float:
+    """Compute a quantile with basic guards; returns NaN for empty input."""
+    if not (0.0 <= q <= 1.0):
+        raise ValueError(f"Quantile q must be in [0, 1]. Got {q}.")
+    if x.size == 0:
+        return np.nan
+    return float(np.quantile(x, q))
+
+
+def _make_tau_grid(
+    abs_errors: np.ndarray,
+    grid: Optional[Union[np.ndarray, Iterable[float]]] = None,
+    grid_size: int = 101,
+    grid_quantiles: Tuple[float, float] = (0.0, 0.99),
+) -> np.ndarray:
+    """
+    Construct a non-negative τ grid.
+
+    If ``grid`` is provided, it is filtered to finite, unique, non-negative values.
+    Otherwise, a linear grid is constructed between quantiles of the absolute error
+    distribution.
+    """
+    if abs_errors.size == 0:
+        return np.array([], dtype=float)
+
+    if grid is not None:
+        g = _to_1d_float_array(grid)
+        g = g[np.isfinite(g)]
+        g = np.unique(g)
+        g = g[g >= 0]
+        return g
+
+    q_lo, q_hi = grid_quantiles
+    if not (0 <= q_lo <= q_hi <= 1):
+        raise ValueError(
+            f"grid_quantiles must satisfy 0 <= q_lo <= q_hi <= 1. Got {grid_quantiles}."
+        )
+
+    lo = _quantile(abs_errors, q_lo)
+    hi = _quantile(abs_errors, q_hi)
+
+    if not np.isfinite(lo) or not np.isfinite(hi):
+        return np.array([], dtype=float)
+
+    if hi < lo:
+        hi = lo
+
+    if grid_size < 2:
+        return np.array([lo], dtype=float)
+
+    return np.linspace(lo, hi, grid_size, dtype=float)
+
+
+def hr_at_tau(
+    y: Union[pd.Series, np.ndarray, Iterable[float]],
+    yhat: Union[pd.Series, np.ndarray, Iterable[float]],
+    tau: float,
+) -> float:
+    r"""
+    Compute HR@τ: fraction of observations whose absolute error is within τ.
+
+    HR@τ is defined as:
+
+    $$
+    \mathrm{HR}@\tau = \frac{1}{n}\sum_{i=1}^{n}\mathbf{1}\left(|y_i-\hat{y}_i|\le \tau\right)
+    $$
+
+    This is an evaluation-friendly wrapper around the core implementation in
+    ``eb_metrics.metrics.service.hr_at_tau``. Non-finite (y, yhat) pairs are dropped
+    prior to delegating. If no finite pairs remain, returns ``np.nan``.
+    """
+    tau = _validate_tau(tau)
+
+    y_arr = _to_1d_float_array(y)
+    yhat_arr = _to_1d_float_array(yhat)
+    if y_arr.shape[0] != yhat_arr.shape[0]:
+        raise ValueError(
+            f"y and yhat must have the same length. Got {len(y_arr)} vs {len(yhat_arr)}."
+        )
+
+    mask = np.isfinite(y_arr) & np.isfinite(yhat_arr)
+    if not np.any(mask):
+        return np.nan
+
+    return float(_hr_at_tau_core(y_true=y_arr[mask], y_pred=yhat_arr[mask], tau=tau))
+
+
+@dataclass(frozen=True)
+class TauEstimate:
+    """
+    Result container for τ estimation.
+
+    Attributes
+    ----------
+    tau : float
+        Estimated tolerance τ (may be NaN if estimation failed).
+    method : str
+        Method identifier used to produce the estimate.
+    n : int
+        Number of finite (y, yhat) pairs used.
+    diagnostics : dict[str, Any]
+        Method-specific diagnostics intended for reporting and governance.
+    """
+
+    tau: float
+    method: str
+    n: int
+    diagnostics: Dict[str, Any]
+
+
+def estimate_tau(
+    y: Union[pd.Series, np.ndarray, Iterable[float]],
+    yhat: Union[pd.Series, np.ndarray, Iterable[float]],
+    method: TauMethod = "target_hit_rate",
+    *,
+    target_hit_rate: float = 0.90,
+    grid: Optional[Union[np.ndarray, Iterable[float]]] = None,
+    grid_size: int = 101,
+    grid_quantiles: Tuple[float, float] = (0.0, 0.99),
+    knee_rule: Literal["slope_threshold", "max_distance"] = "slope_threshold",
+    slope_threshold: float = 0.0025,
+    lambda_: float = 0.10,
+    tau_max: Optional[float] = None,
+    tau_floor: float = 0.0,
+    tau_cap: Optional[float] = None,
+) -> TauEstimate:
+    r"""Estimate a global tolerance τ from residuals.
+
+    See module docstring for method definitions and design notes.
+    """
+    abs_errors = _nan_safe_abs_errors(y, yhat)
+    n = int(abs_errors.size)
+
+    if n == 0:
+        return TauEstimate(
+            tau=np.nan,
+            method=str(method),
+            n=0,
+            diagnostics={"reason": "no_finite_pairs"},
+        )
+
+    tau_floor = _validate_tau(tau_floor)
+    if tau_cap is not None:
+        tau_cap = _validate_tau(tau_cap)
+
+    if method == "target_hit_rate":
+        if not (0.0 < target_hit_rate <= 1.0):
+            raise ValueError(
+                f"target_hit_rate must be in (0, 1]. Got {target_hit_rate}."
+            )
+
+        tau = _quantile(abs_errors, target_hit_rate)
+
+        if np.isfinite(tau):
+            tau = max(tau, tau_floor)
+            if tau_cap is not None:
+                tau = min(tau, tau_cap)
+
+        diag = {
+            "target_hit_rate": float(target_hit_rate),
+            "achieved_hr_calibration": float(np.mean(abs_errors <= tau))
+            if np.isfinite(tau)
+            else np.nan,
+            "abs_error_quantile_used": float(target_hit_rate),
+            "tau_floor": float(tau_floor),
+            "tau_cap": float(tau_cap) if tau_cap is not None else None,
+        }
+        return TauEstimate(tau=float(tau), method="target_hit_rate", n=n, diagnostics=diag)
+
+    tau_grid = _make_tau_grid(
+        abs_errors,
+        grid=grid,
+        grid_size=grid_size,
+        grid_quantiles=grid_quantiles,
+    )
+    if tau_grid.size == 0:
+        return TauEstimate(
+            tau=np.nan,
+            method=str(method),
+            n=n,
+            diagnostics={"reason": "empty_tau_grid"},
+        )
+
+    # HR curve on grid (monotone non-decreasing)
+    e_sorted = np.sort(abs_errors)
+    idx = np.searchsorted(e_sorted, tau_grid, side="right")
+    hr_curve = idx / float(n)
+
+    if method == "knee":
+        if knee_rule == "slope_threshold":
+            d_tau = np.diff(tau_grid)
+            d_hr = np.diff(hr_curve)
+            slope = np.where(d_tau > 0, d_hr / d_tau, np.inf)
+
+            candidates = np.where(slope < slope_threshold)[0]
+            pick_i = (
+                int(candidates[0] + 1) if candidates.size > 0 else int(len(tau_grid) - 1)
+            )
+
+            tau = float(tau_grid[pick_i])
+            hr_pick = float(hr_curve[pick_i])
+
+            diag = {
+                "knee_rule": knee_rule,
+                "slope_threshold": float(slope_threshold),
+                "picked_index": pick_i,
+                "picked_hr_calibration": hr_pick,
+                "grid_size": int(tau_grid.size),
+                "tau_grid_min": float(tau_grid.min()),
+                "tau_grid_max": float(tau_grid.max()),
+                "tau_floor": float(tau_floor),
+                "tau_cap": float(tau_cap) if tau_cap is not None else None,
+            }
+
+        elif knee_rule == "max_distance":
+            t0, t1 = float(tau_grid[0]), float(tau_grid[-1])
+            t_norm = (tau_grid - t0) / (t1 - t0) if t1 > t0 else np.zeros_like(tau_grid)
+
+            x = t_norm
+            yv = hr_curve
+            x0, y0 = 0.0, float(hr_curve[0])
+            x1, y1 = 1.0, float(hr_curve[-1])
+
+            denom = np.hypot(x1 - x0, y1 - y0)
+            if denom == 0:
+                pick_i = int(len(tau_grid) // 2)
+            else:
+                dist = (
+                    np.abs((y1 - y0) * x - (x1 - x0) * yv + x1 * y0 - y1 * x0) / denom
+                )
+                pick_i = int(np.argmax(dist))
+
+            tau = float(tau_grid[pick_i])
+            hr_pick = float(hr_curve[pick_i])
+
+            diag = {
+                "knee_rule": knee_rule,
+                "picked_index": pick_i,
+                "picked_hr_calibration": hr_pick,
+                "grid_size": int(tau_grid.size),
+                "tau_grid_min": float(tau_grid.min()),
+                "tau_grid_max": float(tau_grid.max()),
+                "tau_floor": float(tau_floor),
+                "tau_cap": float(tau_cap) if tau_cap is not None else None,
+            }
+        else:
+            raise ValueError(f"Unknown knee_rule: {knee_rule}")
+
+        tau = max(tau, tau_floor)
+        if tau_cap is not None:
+            tau = min(tau, tau_cap)
+
+        return TauEstimate(tau=float(tau), method="knee", n=n, diagnostics=diag)
+
+    if method == "utility":
+        if lambda_ < 0:
+            raise ValueError(f"lambda_ must be >= 0. Got {lambda_}.")
+
+        if tau_max is None:
+            tau_max_val = _quantile(abs_errors, 0.99)
+        else:
+            tau_max_val = float(tau_max)
+
+        if not np.isfinite(tau_max_val) or tau_max_val <= 0:
+            tau_max_val = (
+                float(tau_grid[-1])
+                if np.isfinite(tau_grid[-1]) and tau_grid[-1] > 0
+                else 1.0
+            )
+
+        utility = hr_curve - float(lambda_) * (tau_grid / tau_max_val)
+        pick_i = int(np.argmax(utility))
+
+        tau = float(tau_grid[pick_i])
+        hr_pick = float(hr_curve[pick_i])
+        u_pick = float(utility[pick_i])
+
+        tau = max(tau, tau_floor)
+        if tau_cap is not None:
+            tau = min(tau, tau_cap)
+
+        diag = {
+            "lambda_": float(lambda_),
+            "tau_max": float(tau_max_val),
+            "picked_index": pick_i,
+            "picked_hr_calibration": hr_pick,
+            "picked_utility": u_pick,
+            "grid_size": int(tau_grid.size),
+            "tau_grid_min": float(tau_grid.min()),
+            "tau_grid_max": float(tau_grid.max()),
+            "tau_floor": float(tau_floor),
+            "tau_cap": float(tau_cap) if tau_cap is not None else None,
+        }
+        return TauEstimate(tau=float(tau), method="utility", n=n, diagnostics=diag)
+
+    raise ValueError(f"Unknown method: {method}")
+
+
+def estimate_entity_tau(
+    df: pd.DataFrame,
+    *,
+    entity_col: str,
+    y_col: str,
+    yhat_col: str,
+    method: TauMethod = "target_hit_rate",
+    min_n: int = 30,
+    estimate_kwargs: Optional[Mapping[str, Any]] = None,
+    cap_with_global: bool = False,
+    global_cap_quantile: float = 0.99,
+    include_diagnostics: bool = True,
+) -> pd.DataFrame:
+    r"""Estimate τ per entity from residuals. See the original EB docs for details."""
+    if estimate_kwargs is None:
+        estimate_kwargs = {}
+
+    required = {entity_col, y_col, yhat_col}
+    missing = [c for c in required if c not in df.columns]
+    if missing:
+        raise KeyError(f"Missing required columns: {missing}")
+
+    if min_n < 1:
+        raise ValueError(f"min_n must be >= 1. Got {min_n}.")
+
+    global_cap = None
+    if cap_with_global:
+        abs_errors_all = _nan_safe_abs_errors(df[y_col], df[yhat_col])
+        global_cap = _quantile(abs_errors_all, global_cap_quantile)
+        if not np.isfinite(global_cap):
+            global_cap = None
+
+    rows: list[dict[str, Any]] = []
+
+    for ent, g in df.groupby(entity_col, dropna=False):
+        abs_errors = _nan_safe_abs_errors(g[y_col], g[yhat_col])
+        n = int(abs_errors.size)
+
+        if n < min_n:
+            rows.append(
+                {
+                    entity_col: ent,
+                    "tau": np.nan,
+                    "n": n,
+                    "method": method,
+                    "reason": f"min_n_not_met(<{min_n})",
+                }
+            )
+            continue
+
+        est = estimate_tau(
+            y=g[y_col],
+            yhat=g[yhat_col],
+            method=method,
+            **dict(estimate_kwargs),
+        )
+
+        tau_val = est.tau
+        if global_cap is not None and np.isfinite(tau_val):
+            tau_val = float(min(tau_val, global_cap))
+
+        row: dict[str, Any] = {
+            entity_col: ent,
+            "tau": tau_val,
+            "n": est.n,
+            "method": est.method,
+        }
+
+        if include_diagnostics:
+            diag = dict(est.diagnostics or {})
+            row["diagnostics"] = diag
+            row["achieved_hr_calibration"] = diag.get(
+                "achieved_hr_calibration", diag.get("picked_hr_calibration")
+            )
+            row["tau_floor"] = diag.get("tau_floor")
+            row["tau_cap"] = diag.get("tau_cap")
+            if method == "utility":
+                row["lambda_"] = diag.get("lambda_")
+                row["tau_max"] = diag.get("tau_max")
+                row["picked_utility"] = diag.get("picked_utility")
+            if method == "knee":
+                row["knee_rule"] = diag.get("knee_rule")
+
+        if global_cap is not None:
+            row["global_cap_tau"] = global_cap
+            row["global_cap_quantile"] = float(global_cap_quantile)
+
+        rows.append(row)
+
+    out = pd.DataFrame(rows)
+
+    base_cols = [entity_col, "tau", "n", "method"]
+    extra_cols = [c for c in out.columns if c not in base_cols]
+    return out[base_cols + extra_cols]
+
+
+def hr_auto_tau(
+    y: Union[pd.Series, np.ndarray, Iterable[float]],
+    yhat: Union[pd.Series, np.ndarray, Iterable[float]],
+    method: TauMethod = "target_hit_rate",
+    **estimate_kwargs: Any,
+) -> Tuple[float, float, Dict[str, Any]]:
+    r"""Estimate τ from residuals, then compute HR@τ. Returns (hr, tau, diagnostics)."""
+    est = estimate_tau(y=y, yhat=yhat, method=method, **estimate_kwargs)
+    if not np.isfinite(est.tau):
+        return (np.nan, np.nan, dict(est.diagnostics or {}))
+
+    hr = hr_at_tau(y, yhat, est.tau)
+    return (float(hr), float(est.tau), dict(est.diagnostics or {}))

eb_optimization-0.1.0.dist-info/METADATA

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: eb-optimization
+Version: 0.1.0
+Summary: Electric Barometer: Optimization and tuning utilities for EB objectives and policy parameters.
+Author-email: "Kyle Corrie (Economistician)" <kcorrie@economistician.com>
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://github.com/Economistician/eb-optimization
+Project-URL: Repository, https://github.com/Economistician/eb-optimization
+Project-URL: Issues, https://github.com/Economistician/eb-optimization/issues
+Project-URL: Documentation, https://github.com/Economistician/eb-docs
+Keywords: electric-barometer,optimization,tuning,grid-search,calibration,asymmetric-loss,forecasting,pandas
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: pandas>=2.0
+Provides-Extra: eb
+Requires-Dist: eb-metrics<0.3,>=0.2; extra == "eb"
+Requires-Dist: eb-evaluation<0.3,>=0.2; extra == "eb"
+Provides-Extra: opt
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == "test"
+Requires-Dist: scikit-learn>=1.3; extra == "test"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-cov>=5.0; extra == "dev"
+Dynamic: license-file
+
+# Electric Barometer · Optimization (`eb-optimization`)
+
+Decision and policy layer for the Electric Barometer ecosystem, responsible for tuning, calibration, and governed parameter selection.
+
+---
+
+## Overview
+
+This repository contains the optimization, tuning, and policy governance layer of the Electric Barometer ecosystem. It defines how key evaluation parameters—such as cost ratios, tolerances, and readiness controls—are selected from data, validated under governance rules, and formalized into deterministic policies that can be reused across systems and environments.
+
+Rather than computing metrics or running evaluations, this repository focuses on decision logic: how parameters are calibrated, how tradeoffs are resolved, and how those decisions are frozen into auditable artifacts. It provides the bridge between metric theory and operational deployment, ensuring that forecast evaluation behavior is consistent, explainable, and governed by explicit intent rather than ad-hoc configuration.
+
+---
+
+## Role in the Electric Barometer Ecosystem
+
+`eb-optimization` defines the parameter selection, calibration, and governance logic used throughout the Electric Barometer ecosystem. It is responsible for determining how key operational parameters—such as cost ratios, tolerance bands, and readiness controls—are selected from data in a disciplined, reproducible, and decision-aware manner.
+
+This repository focuses exclusively on optimization mechanics and policy formation. It does not define metric primitives, perform evaluation orchestration, manage model interfaces, or execute runtime decision logic. Those responsibilities are handled by adjacent layers in the ecosystem that compute metrics, evaluate forecasts, or apply frozen policies in production workflows.
+
+By separating parameter selection and governance from metric semantics and execution concerns, eb-optimization provides a stable optimization layer that enables consistent calibration, transparent decision rules, and auditable policy artifacts across heterogeneous forecasting and operational contexts.
+
+---
+
+## Installation
+
+`eb-optimization` is distributed as a standard Python package.
+
+```bash
+pip install eb-optimization
+```
+
+---
+
+## Core Concepts
+
+- **Parameter governance** — Operational parameters (e.g., cost ratios, tolerances) should be selected through explicit, reproducible rules rather than ad-hoc tuning or implicit defaults.
+- **Search over candidate spaces** — Optimization is framed as deterministic search over bounded, interpretable candidate sets, enabling transparent tradeoffs and stable outcomes.
+- **Cost balance calibration** — Asymmetric operational costs can be balanced by selecting parameters that equalize or appropriately trade off opposing risk exposures.
+- **Tolerance selection from residuals** — Acceptable error bands can be learned directly from historical performance, reflecting empirical system behavior rather than arbitrary thresholds.
+- **Policy separation** — Calibration logic is separated from frozen policy artifacts so that parameter selection is auditable, versioned, and safely applied in downstream systems.
+- **Decision-aligned optimization** — Optimization is evaluated by operational interpretability and governance fitness, not by abstract numerical optimality alone.
+
+---
+
+## Minimal Example
+
+The example below illustrates a typical optimization workflow using `eb-optimization`: calibrating an operational parameter from historical data and applying it via a frozen policy.
+
+```python
+import numpy as np
+from eb_optimization.policies import (
+    CostRatioPolicy,
+    apply_cost_ratio_policy,
+)
+
+# Historical actuals and forecasts
+y_true = np.array([10, 12, 15, 20])
+y_pred = np.array([9, 14, 18, 17])
+
+# Define a frozen cost-ratio policy
+policy = CostRatioPolicy(
+    R_grid=(0.5, 1.0, 2.0, 3.0),
+    co=1.0,
+)
+
+# Estimate a global cost ratio R
+R, diagnostics = apply_cost_ratio_policy(
+    y_true=y_true,
+    y_pred=y_pred,
+    policy=policy,
+)
+
+print(R)
+```
+
+---
+
+## License
+
+BSD 3-Clause License.  
+© 2025 Kyle Corrie.

eb_optimization-0.1.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+eb_optimization/__init__.py,sha256=XtzNvrJkzZ-dR362SsVOYychYWy1Akc3APIob-Vzxg0,1214
+eb_optimization/_utils.py,sha256=TdhPz5t327xah97_1lMluEvjskVrHWpxGDZ8rWzTYUc,2743
+eb_optimization/policies/__init__.py,sha256=WO8cH2a7uDNCiWBKXggazFL_UUYgRMi9d0p3QrPBKug,2285
+eb_optimization/policies/cost_ratio_policy.py,sha256=Nrkc8zWUE_s44Db8BjhciESltbq1Uj4dYNcA7V_DcRQ,10404
+eb_optimization/policies/ral_policy.py,sha256=SWdIieZL__Ho6jep57y8FjOz5NSZnISXZxnYGUYTJhg,5080
+eb_optimization/policies/tau_policy.py,sha256=fvE_3VLut8M9pwla4msTWv5Yn0EJKCGHsn9R4znfPSo,4416
+eb_optimization/search/__init__.py,sha256=uxAPhOaryEM5kM4tOHLH0-z5oaE6Qf_UxcOBYt74jpk,797
+eb_optimization/search/grid.py,sha256=9LEkxaq8tdRPHp6zQzKEnKijTCvisib3mFMhQ_vh0w8,3088
+eb_optimization/search/kernels.py,sha256=EN3N5ZHeI4lx4CYm81r0_e6YBXGB-th181F3Es_IbuU,3481
+eb_optimization/search/results.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eb_optimization/tuning/__init__.py,sha256=UqNzxcQtq36M4IH2G0i01961P2wIw1HQruMhfqfWMLo,834
+eb_optimization/tuning/cost_ratio.py,sha256=mKxex7Pi322Y1vj_TQMOP3GtXouUdE23Ny51kctt4H8,9451
+eb_optimization/tuning/ral.py,sha256=_1sGi62uowAqauizrZvSssZpjL7vrr1L_wK4pTWziX0,5106
+eb_optimization/tuning/sensitivity.py,sha256=TZyqFuQiXvlpLVmztM54QnVZ-go0HsopoA9VrewXbII,10078
+eb_optimization/tuning/tau.py,sha256=mBvfebwLnwTUegqLinwtYdBxL9-qEL3F2iDQpbbC7V0,16802
+eb_optimization-0.1.0.dist-info/licenses/LICENSE,sha256=qFjBKWIfPVLU4ZK4DgROjINVdZVLuNznTfyVaEgCa9w,1526
+eb_optimization-0.1.0.dist-info/METADATA,sha256=Qmh8lj5DOPr0BIVDHQCdN33hZsRiJFJ80RFzf63Ozuw,5762
+eb_optimization-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+eb_optimization-0.1.0.dist-info/top_level.txt,sha256=hQbl5B7gB8EaF7MiEtsGz6OoU64r38bAPKdaN4M1Aho,16
+eb_optimization-0.1.0.dist-info/RECORD,,

eb_optimization-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

eb_optimization-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, Kyle Corrie
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

eb_optimization-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+eb_optimization