from __future__ import annotations from dataclasses import dataclass from typing import Dict, List, Optional import numpy as np from sklearn.ensemble import RandomForestRegressor try: from xgboost import XGBRegressor except Exception: # pragma: no cover XGBRegressor = None # type: ignore[assignment] @dataclass class SurrogateConfig: prefer_xgboost: bool = True random_state: int = 42 n_estimators: int = 200 min_train_samples: int = 8 max_depth_small: int = 3 max_depth_large: int = 6 class SurrogateModel: """Surrogate model with explicit missing-feature masking support.""" def __init__(self, config: Optional[SurrogateConfig] = None): self.config = config or SurrogateConfig() self.model = None self.backend = "uninitialized" self.feature_names: List[str] = [] self.mask_names: List[str] = [] self._median: np.ndarray | None = None self._iqr: np.ndarray | None = None self._train_x: np.ndarray | None = None self._train_y: np.ndarray | None = None self.last_fit_stats: Dict[str, float] = {} def _build_model(self, n_samples: int): max_depth = self.config.max_depth_small if n_samples < 50 else self.config.max_depth_large if self.config.prefer_xgboost and XGBRegressor is not None: self.backend = "xgboost" return XGBRegressor( n_estimators=self.config.n_estimators, max_depth=max_depth, learning_rate=0.05, subsample=0.9, colsample_bytree=0.9, reg_alpha=0.1, reg_lambda=1.0, random_state=self.config.random_state, ) self.backend = "random_forest" return RandomForestRegressor( n_estimators=max(100, self.config.n_estimators), max_depth=max_depth, random_state=self.config.random_state, n_jobs=-1, ) def _fit_normalizer(self, x: np.ndarray, m: np.ndarray) -> None: med = [] iqr = [] for j in range(x.shape[1]): vals = x[m[:, j] > 0.5, j] if vals.size == 0: med.append(0.0) iqr.append(1.0) continue q1 = float(np.quantile(vals, 0.25)) q3 = float(np.quantile(vals, 0.75)) inter = max(1e-6, q3 - q1) med.append(float(np.median(vals))) iqr.append(inter) self._median = np.asarray(med, dtype=float) self._iqr = np.asarray(iqr, dtype=float) def _transform(self, x: np.ndarray, m: np.ndarray, fit: bool = False) -> np.ndarray: x = np.asarray(x, dtype=float) m = np.asarray(m, dtype=float) if fit or self._median is None or self._iqr is None: self._fit_normalizer(x, m) assert self._median is not None and self._iqr is not None x_filled = np.where(np.isfinite(x), x, np.nan) for j in range(x.shape[1]): col = x_filled[:, j] missing = ~np.isfinite(col) col[missing] = self._median[j] x_filled[:, j] = (col - self._median[j]) / self._iqr[j] # Explicit missingness information: concatenate mask vector. return np.concatenate([x_filled, m], axis=1) def fit( self, features: np.ndarray, masks: np.ndarray, y: np.ndarray, feature_names: List[str], mask_names: List[str], ) -> Dict[str, float]: y = np.asarray(y, dtype=float) valid = np.isfinite(y) n_samples = int(np.sum(valid)) self.feature_names = list(feature_names) self.mask_names = list(mask_names) if n_samples < self.config.min_train_samples: self.model = None self.backend = "warmup" self.last_fit_stats = { "n_train": float(n_samples), "train_mae": np.nan, "val_mae": np.nan, "instability_ratio": 1.0, } return self.last_fit_stats x = np.asarray(features, dtype=float)[valid] m = np.asarray(masks, dtype=float)[valid] yv = y[valid] x_trans = self._transform(x, m, fit=True) self._train_x = x_trans self._train_y = yv self.model = self._build_model(n_samples=n_samples) self.model.fit(x_trans, yv) train_pred = self.model.predict(x_trans) train_mae = float(np.mean(np.abs(train_pred - yv))) # Simple rolling validation proxy. if n_samples >= 12: split = int(max(8, n_samples * 0.8)) x_tr, x_val = x_trans[:split], x_trans[split:] y_tr, y_val = yv[:split], yv[split:] val_model = self._build_model(n_samples=split) val_model.fit(x_tr, y_tr) val_pred = val_model.predict(x_val) val_mae = float(np.mean(np.abs(val_pred - y_val))) if y_val.size else train_mae else: val_mae = train_mae instability = float((val_mae + 1e-6) / (train_mae + 1e-6)) self.last_fit_stats = { "n_train": float(n_samples), "train_mae": train_mae, "val_mae": val_mae, "instability_ratio": instability, } return self.last_fit_stats def _rf_uncertainty(self, x: np.ndarray) -> np.ndarray: assert self.model is not None if not hasattr(self.model, "estimators_"): return np.full(x.shape[0], float(np.std(self._train_y)) if self._train_y is not None else 1.0) preds = np.vstack([tree.predict(x) for tree in self.model.estimators_]) return np.std(preds, axis=0) def predict_bundle(self, features: np.ndarray, masks: np.ndarray, topk_threshold: float | None = None) -> Dict[str, np.ndarray]: n = features.shape[0] if self.model is None: return { "expected_score": np.zeros(n, dtype=float), "topk_probability": np.full(n, 0.5, dtype=float), "uncertainty": np.full(n, 1.0, dtype=float), } x = self._transform(np.asarray(features, dtype=float), np.asarray(masks, dtype=float), fit=False) expected = self.model.predict(x) if self.backend == "random_forest": uncertainty = self._rf_uncertainty(x) else: residual_scale = ( float(np.std(self._train_y - self.model.predict(self._train_x))) if self._train_x is not None and self._train_y is not None else 1.0 ) uncertainty = np.full(expected.shape[0], max(1e-3, residual_scale)) if topk_threshold is None: topk_threshold = float(np.quantile(self._train_y, 0.8)) if self._train_y is not None else 0.0 z = (expected - topk_threshold) / (uncertainty + 1e-6) topk_prob = 1.0 / (1.0 + np.exp(-z)) return { "expected_score": expected.astype(float), "topk_probability": topk_prob.astype(float), "uncertainty": uncertainty.astype(float), } def feature_importance(self) -> Dict[str, float]: if self.model is None or not hasattr(self.model, "feature_importances_"): return {} names = self.feature_names + self.mask_names importances = np.asarray(self.model.feature_importances_, dtype=float) if importances.size != len(names): return {} return {name: float(value) for name, value in zip(names, importances)}