"""Fold-local imputation, scaling, PCA, and target scaling.""" from __future__ import annotations import pickle from pathlib import Path from typing import Any, Dict, Optional import numpy as np from sklearn.decomposition import PCA class FeaturePreprocessor: def __init__( self, impute: str = "median", standardize: bool = True, pca: int = 0, seed: int = 42, ): self.impute = impute self.standardize = bool(standardize) self.pca = int(pca or 0) self.seed = int(seed) self.impute_values_: Optional[np.ndarray] = None self.mean_: Optional[np.ndarray] = None self.std_: Optional[np.ndarray] = None self.pca_: Optional[PCA] = None self.n_features_in_: Optional[int] = None def _clean(self, X: np.ndarray) -> np.ndarray: X = np.asarray(X, dtype=np.float64) X = np.where(np.isfinite(X), X, np.nan) return X def fit(self, X: np.ndarray) -> "FeaturePreprocessor": X = self._clean(X) if X.size == 0: raise ValueError("Cannot fit preprocessor on empty X") self.n_features_in_ = X.shape[1] if self.impute == "median": vals = np.nanmedian(X, axis=0) elif self.impute == "mean": vals = np.nanmean(X, axis=0) elif self.impute == "zero": vals = np.zeros(X.shape[1]) else: raise ValueError(f"Unknown impute: {self.impute}") vals = np.where(np.isfinite(vals), vals, 0.0) self.impute_values_ = vals X = np.where(np.isnan(X), vals, X) if self.standardize: self.mean_ = X.mean(axis=0) self.std_ = X.std(axis=0) self.std_ = np.where(self.std_ > 0, self.std_, 1.0) X = (X - self.mean_) / self.std_ if self.pca > 0 and self.pca < min(X.shape): self.pca_ = PCA(n_components=self.pca, random_state=self.seed) self.pca_.fit(X) return self def transform(self, X: np.ndarray) -> np.ndarray: if self.impute_values_ is None: raise RuntimeError("Preprocessor not fitted") X = self._clean(X) if X.shape[1] != self.n_features_in_: raise ValueError(f"Expected {self.n_features_in_} features, got {X.shape[1]}") X = np.where(np.isnan(X), self.impute_values_, X) if self.standardize: X = (X - self.mean_) / self.std_ if self.pca_ is not None: X = self.pca_.transform(X) return X.astype(np.float32) def fit_transform(self, X: np.ndarray) -> np.ndarray: return self.fit(X).transform(X) def n_features_out(self) -> int: if self.pca_ is not None: return int(self.pca_.n_components_) return int(self.n_features_in_) def save(self, path: str | Path) -> None: p = Path(path) p.parent.mkdir(parents=True, exist_ok=True) with open(p, "wb") as f: pickle.dump(self, f) @staticmethod def load(path: str | Path) -> "FeaturePreprocessor": with open(path, "rb") as f: return pickle.load(f) class TargetScaler: def __init__(self): self.mean_: Optional[np.ndarray] = None self.std_: Optional[np.ndarray] = None def fit(self, Y: np.ndarray, M: np.ndarray) -> "TargetScaler": Y = np.asarray(Y, dtype=np.float64) M = np.asarray(M, dtype=np.float64) counts = M.sum(axis=0) counts = np.where(counts > 0, counts, 1.0) mean = (Y * M).sum(axis=0) / counts var = (((Y - mean) ** 2) * M).sum(axis=0) / counts std = np.sqrt(np.maximum(var, 0)) std = np.where(std > 0, std, 1.0) self.mean_ = mean self.std_ = std return self def transform(self, Y: np.ndarray) -> np.ndarray: return (Y - self.mean_) / self.std_ def inverse(self, Y: np.ndarray) -> np.ndarray: return Y * self.std_ + self.mean_ def save(self, path: str | Path) -> None: p = Path(path) p.parent.mkdir(parents=True, exist_ok=True) with open(p, "wb") as f: pickle.dump(self, f) @staticmethod def load(path: str | Path) -> "TargetScaler": with open(path, "rb") as f: return pickle.load(f) def make_preprocessor(data_cfg: Dict[str, Any]) -> FeaturePreprocessor: pca = 0 if data_cfg.get("proteins", {}).get("enabled", False): pca = int(data_cfg.get("proteins", {}).get("pca", 0) or 0) return FeaturePreprocessor( impute=data_cfg.get("impute", "median"), standardize=bool(data_cfg.get("standardize", True)), pca=pca, seed=int(data_cfg.get("seed", 42)), )