fryabcfry's picture
Publish AMP-PD checkpoints, portable loaders and verified metrics (part 3)
04ae9bb verified
Raw History Blame Contribute Delete
4.74 kB
"""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)),
)