File size: 4,738 Bytes
04ae9bb | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 | """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)),
)
|