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)),
    )