Download code/ampd/data/preprocess.py from fryabcfry/cs4486-amp-pd-checkpoints: direct link, hf CLI and curl.
- Browser
- Download file 4.74 kB
-
https://huggingface.co/fryabcfry/cs4486-amp-pd-checkpoints/resolve/main/code/ampd/data/preprocess.py
- Command line
-
hf download hf://fryabcfry/cs4486-amp-pd-checkpoints/code/ampd/data/preprocess.py
-
curl -L -o preprocess.py https://huggingface.co/fryabcfry/cs4486-amp-pd-checkpoints/resolve/main/code/ampd/data/preprocess.py
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) | |
| 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) | |
| 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)), | |
| ) | |