| from __future__ import annotations |
|
|
| from dataclasses import dataclass |
| from typing import Dict, List, Sequence |
|
|
| import numpy as np |
|
|
|
|
| @dataclass |
| class DynamicThresholdConfig: |
| min_evaluated: int = 500 |
| patience_rounds: int = 8 |
| min_model_weight: float = 0.35 |
| quantile: float = 0.15 |
| uncertainty_weight: float = 0.20 |
| min_improvement: float = 0.02 |
| exploration_margin: float = 0.45 |
| exploitation_margin: float = 0.10 |
| reference_evaluations: int = 5000 |
|
|
|
|
| class DynamicEarlyStopController: |
| """ |
| Conservative early-stop controller for adaptive replay. |
| |
| Lower scores are considered better. |
| """ |
|
|
| def __init__(self, config: DynamicThresholdConfig | None = None) -> None: |
| self.config = config or DynamicThresholdConfig() |
| self.best_score = np.inf |
| self.stagnant_rounds = 0 |
| self.history: List[Dict[str, float | int | bool | str]] = [] |
|
|
| def update( |
| self, |
| *, |
| round_idx: int, |
| n_evaluated: int, |
| all_scores: Sequence[float], |
| recent_scores: Sequence[float], |
| model_weight: float, |
| mean_uncertainty: float, |
| ) -> Dict[str, float | int | bool | str]: |
| cfg = self.config |
| scores = np.asarray(all_scores, dtype=float) |
| recent = np.asarray(recent_scores, dtype=float) |
|
|
| if scores.size == 0: |
| rec = { |
| "round_idx": int(round_idx), |
| "n_evaluated": int(n_evaluated), |
| "dynamic_threshold": np.nan, |
| "score_quantile": np.nan, |
| "best_score": np.nan, |
| "recent_mean_score": np.nan, |
| "mean_uncertainty": float(mean_uncertainty), |
| "model_weight": float(model_weight), |
| "stagnant_rounds": int(self.stagnant_rounds), |
| "eligible_for_stop": False, |
| "stop": False, |
| "reason": "no_scores", |
| } |
| self.history.append(rec) |
| return rec |
|
|
| score_quantile = float(np.nanquantile(scores, cfg.quantile)) |
| best = float(np.nanmin(scores)) |
| recent_mean = float(np.nanmean(recent)) if recent.size else float(np.nan) |
| uncertainty = float(max(0.0, mean_uncertainty)) |
|
|
| if np.isfinite(self.best_score): |
| improvement = float(self.best_score - best) |
| else: |
| improvement = np.inf |
|
|
| if improvement > cfg.min_improvement: |
| self.stagnant_rounds = 0 |
| else: |
| self.stagnant_rounds += 1 |
| self.best_score = min(self.best_score, best) |
|
|
| coverage = float(min(1.0, n_evaluated / max(1.0, float(cfg.reference_evaluations)))) |
| margin = (1.0 - coverage) * cfg.exploration_margin + coverage * cfg.exploitation_margin |
| dynamic_threshold = float(score_quantile + margin + cfg.uncertainty_weight * uncertainty) |
|
|
| eligible = ( |
| int(n_evaluated) >= int(cfg.min_evaluated) |
| and float(model_weight) >= float(cfg.min_model_weight) |
| ) |
| plateau = self.stagnant_rounds >= int(cfg.patience_rounds) |
| poor_recent = bool(np.isfinite(recent_mean) and recent_mean >= dynamic_threshold) |
| should_stop = bool(eligible and plateau and poor_recent) |
|
|
| if not eligible: |
| reason = "not_eligible" |
| elif not plateau: |
| reason = "improving_or_not_stagnant" |
| elif not poor_recent: |
| reason = "recent_batch_still_competitive" |
| else: |
| reason = "stagnation_above_dynamic_threshold" |
|
|
| rec = { |
| "round_idx": int(round_idx), |
| "n_evaluated": int(n_evaluated), |
| "dynamic_threshold": dynamic_threshold, |
| "score_quantile": score_quantile, |
| "best_score": self.best_score, |
| "recent_mean_score": recent_mean, |
| "mean_uncertainty": uncertainty, |
| "model_weight": float(model_weight), |
| "stagnant_rounds": int(self.stagnant_rounds), |
| "eligible_for_stop": bool(eligible), |
| "stop": should_stop, |
| "reason": reason, |
| } |
| self.history.append(rec) |
| return rec |
|
|
|
|
