decoyfs 0.1.0__py3-none-any.whl

decoyfs/__init__.py

@@ -0,0 +1,25 @@
+"""DecoyFS: decoy-referenced feature selection.
+
+Quick start::
+
+    from decoyfs import DecoySelector
+    sel = DecoySelector().fit(X_train, y_train)
+    X_small = sel.transform(X_test)
+    sel.report_            # audit trail: votes and decoy comparison per feature
+"""
+from __future__ import annotations
+
+from .compare import compare_selectors
+from .decoy import DecoySelector
+from .policies import list_policies, register_policy, unregister_policy
+from .rankers import list_rankers, register_ranker, unregister_ranker
+from .selectors import BorutaSelector, CVKSelector, FixedKSelector, NABFSSelector
+from .validation import DecoyInputError
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "DecoySelector", "FixedKSelector", "CVKSelector", "BorutaSelector", "NABFSSelector", "compare_selectors",
+    "register_ranker", "unregister_ranker", "list_rankers", "register_policy", "unregister_policy", "list_policies",
+    "DecoyInputError", "__version__",
+]

decoyfs/_base.py

@@ -0,0 +1,82 @@
+"""Common machinery of the selectors: validation, per-fold preprocessing and a scikit-learn compatible interface."""
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+from sklearn.base import BaseEstimator, TransformerMixin
+from sklearn.utils.validation import check_is_fitted
+
+from .preprocessing import FoldPrep
+from .validation import DecoyInputError, check_transform_X, check_X_y
+
+
+class BaseSelector(TransformerMixin, BaseEstimator):
+    """Base class: ``fit`` validates and preprocesses, subclasses implement :meth:`_select` on the preprocessed matrix.
+
+    After ``fit``: ``support_`` (boolean mask over the ORIGINAL columns), ``selected_features_`` (names or indices),
+    ``n_features_in_``, ``classes_``, ``preprocessor_`` and ``fit_time_`` (seconds).
+    """
+
+    def _select(self, Z, y, k):
+        """Return the indices (into the columns of ``Z``) of the selected features."""
+        raise NotImplementedError
+
+    def fit(self, X, y):
+        import time
+        t0 = time.perf_counter()
+        Xa, yc, classes, names = check_X_y(X, y)
+        self.n_features_in_ = Xa.shape[1]
+        if names is not None:
+            self.feature_names_in_ = names
+        elif hasattr(self, "feature_names_in_"):
+            del self.feature_names_in_
+        self.classes_ = classes
+        self.preprocessor_ = FoldPrep().fit(Xa)
+        keep = self.preprocessor_.keep_
+        if len(keep) < 2:
+            raise DecoyInputError("Fewer than two non-constant features remain after preprocessing.")
+        Z = self.preprocessor_.transform(Xa)
+        sel = np.asarray(self._select(Z, yc, len(classes)), dtype=int)
+        mask = np.zeros(Xa.shape[1], bool)
+        mask[keep[sel]] = True
+        self.support_ = mask
+        self.fit_time_ = time.perf_counter() - t0
+        return self
+
+    def get_support(self, indices=False):
+        check_is_fitted(self, "support_")
+        return np.where(self.support_)[0] if indices else self.support_.copy()
+
+    @property
+    def selected_features_(self):
+        check_is_fitted(self, "support_")
+        if hasattr(self, "feature_names_in_"):
+            return list(self.feature_names_in_[self.support_])
+        return list(np.where(self.support_)[0])
+
+    def get_feature_names_out(self, input_features=None):
+        check_is_fitted(self, "support_")
+        if input_features is not None:
+            names = np.asarray(input_features, dtype=object)
+        elif hasattr(self, "feature_names_in_"):
+            names = self.feature_names_in_
+        else:
+            names = np.array([f"x{i}" for i in range(self.n_features_in_)], dtype=object)
+        return np.asarray(names[self.support_], dtype=object)
+
+    def transform(self, X):
+        check_is_fitted(self, "support_")
+        Xo = check_transform_X(X, self.n_features_in_, getattr(self, "feature_names_in_", None))
+        if isinstance(Xo, pd.DataFrame):
+            return Xo.loc[:, self.support_]
+        return Xo[:, self.support_]
+
+    def inverse_transform(self, X):
+        check_is_fitted(self, "support_")
+        X = np.asarray(X)
+        out = np.zeros((X.shape[0], self.n_features_in_), dtype=X.dtype)
+        out[:, self.support_] = X
+        return out
+
+    def fit_transform(self, X, y=None, **fit_params):
+        return self.fit(X, y).transform(X)

decoyfs/bench/__init__.py

@@ -0,0 +1,4 @@
+"""Benchmark harness used for the DecoyFS paper (74 OpenML datasets, 4 downstream models, paired statistics).
+
+Requires the ``bench`` extra: ``pip install "decoyfs[bench]"``.
+"""

decoyfs/bench/data.py

@@ -0,0 +1,258 @@
+"""Dataset registry (OpenML) and synthetic generator with known ground truth."""
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass, field
+
+import numpy as np
+
+# Cache of downloaded datasets: override with DECOYFS_CACHE (e.g. to reuse an existing cache).
+CACHE = os.environ.get("DECOYFS_CACHE") or os.path.join(os.path.expanduser("~"), ".cache", "decoyfs")
+
+# short name -> OpenML data_id (verified). Tier order: smoke ⊂ laptop ⊂ full.
+REAL = {
+    # --- tabulares clásicos (p pequeño/mediano)
+    "wdbc": 1510, "diabetes": 37, "credit-g": 31, "ilpd": 1480, "kc1": 1067, "pc4": 1049,
+    "climate": 1467, "steel-plates": 1504, "ozone": 1487, "spambase": 44, "qsar-biodeg": 1494,
+    "vehicle": 54, "segment": 36, "satimage": 182, "optdigits": 28, "texture": 40499,
+    "magic": 1120, "eeg-eye": 1471, "wall-robot": 1497,
+    # --- con atributos-ruido conocidos (AutoML/NIPS-2003)
+    "madelon": 1485, "philippine": 41145, "madeline": 41144, "sylvine": 41146, "jasmine": 41143,
+    "christine": 41142, "gina": 1038,
+    # --- alta dimensión
+    "cnae-9": 1468, "har": 1478, "isolet": 300, "bioresponse": 4134, "arcene": 1458,
+    "internet-ads": 40978, "micro-mass": 1514, "mfeat-factors": 12, "dna": 40670,
+    # --- grandes en n
+    "bank": 1461, "nomao": 1486, "electricity": 151,
+}
+
+# Extensión de validez externa: 20 datasets de OpenML-CC18 (estudio 99) no incluidos arriba, con n<=50k, p<=~1.6k,
+# >=10 atributos, sin duplicados de REAL (segment/steel-plates/climate ya están bajo otros ids).
+REAL_EXT = {
+    "vowel": 307, "adult": 1590, "letter": 6, "pendigits": 32, "eucalyptus": 188, "churn": 40701,
+    "jm1": 1053, "pc1": 1068, "sick": 38, "phishing": 4534, "gesture": 4538, "kr-vs-kp": 3,
+    "cylinder-bands": 6332, "mfeat-zernike": 22, "first-order-tp": 1475, "splice": 46,
+    "authorship": 458, "mice-protein": 40966, "semeion": 1501, "mfeat-fourier": 14,
+}
+REAL.update(REAL_EXT)
+
+# (n, p, n_inf, n_red, clusters, heavy_tail, minority_frac, label_noise)
+SYN = {
+    "syn01": (1000, 50, 5, 5, 1, False, 0.5, 0.01),
+    "syn02": (1000, 50, 5, 5, 2, True, 0.5, 0.01),
+    "syn03": (2000, 200, 10, 10, 2, False, 0.5, 0.01),
+    "syn04": (2000, 200, 10, 10, 2, True, 0.2, 0.03),
+    "syn05": (500, 500, 10, 10, 2, False, 0.5, 0.01),
+    "syn06": (500, 500, 10, 10, 2, True, 0.1, 0.03),
+    "syn07": (5000, 100, 8, 8, 3, True, 0.1, 0.01),
+    "syn08": (5000, 1000, 20, 20, 2, False, 0.5, 0.01),
+    "syn09": (200, 1000, 5, 5, 1, False, 0.5, 0.0),
+    "syn10": (200, 1000, 5, 5, 1, True, 0.5, 0.0),
+    "syn11": (3000, 300, 15, 15, 4, True, 0.3, 0.05),
+    "syn12": (1500, 30, 6, 0, 2, False, 0.5, 0.0),
+}
+
+# Sintéticos dependientes (bloques correlacionados, XOR, proxies): truth 2 causal, 1 proxy, 0 ruido (independiente o
+# en bloques). kind: "block" (factor por bloques), "xor" (interacciones sin señal marginal), "proxy".
+# dict(n, p, kind, block_size, rho, n_causal, proxies_per_causal, minority, label_noise, heavy)
+SYN2 = {
+    "syn13": dict(n=1000, p=200, kind="block", block_size=10, rho=0.6, n_causal=8, minority=0.4, noise=0.02, heavy=False),
+    "syn14": dict(n=300, p=1000, kind="block", block_size=20, rho=0.8, n_causal=6, minority=0.5, noise=0.02, heavy=True),
+    "syn15": dict(n=2000, p=100, kind="xor", n_xor=3, n_lin=2, minority=0.5, noise=0.02, heavy=False),
+    "syn16": dict(n=2000, p=100, kind="proxy", n_causal=10, proxies_per_causal=2, rho=0.7, noise_block=10,
+                  minority=0.3, noise=0.03, heavy=True),
+}
+SYN_ALL = list(SYN) + list(SYN2)
+
+TIERS = {
+    "smoke": ["wdbc", "qsar-biodeg", "syn01", "syn02"],
+    "laptop": ["wdbc", "diabetes", "credit-g", "ilpd", "kc1", "pc4", "climate", "steel-plates", "ozone",
+               "spambase", "qsar-biodeg", "vehicle", "segment", "satimage", "optdigits", "texture",
+               "madelon", "philippine", "madeline", "sylvine", "jasmine", "gina", "cnae-9", "magic",
+               ] + list(SYN),
+    "full": list(REAL) + SYN_ALL,
+}
+# datasets grandes en n para el análisis de sensibilidad a max_n (se corren aparte, ver notebook)
+MAXN_SENS = ["bank", "nomao", "electricity", "magic", "letter", "eeg-eye", "adult", "gina", "jm1"]
+
+
+@dataclass
+class Dataset:
+    name: str
+    X: np.ndarray                      # float32, puede tener NaN
+    y: np.ndarray                      # int 0..k-1
+    feature_names: list
+    truth: np.ndarray | None = None    # 0 ruido, 1 redundante, 2 informativo (solo sintéticos)
+    meta: dict = field(default_factory=dict)
+
+
+def _encode(df):
+    """Binarias -> 0/1; categóricas de 3..12 niveles -> one-hot; resto -> códigos ordinales."""
+    import pandas as pd
+    cols, names = [], []
+    for c in df.columns:
+        s = df[c]
+        if s.dtype.name in ("category", "object", "bool", "string"):
+            s = s.astype("category")
+            cats = list(s.cat.categories)
+            codes = s.cat.codes.to_numpy().astype("float32")
+            codes[codes < 0] = np.nan
+            if len(cats) <= 2 or len(cats) > 12:
+                cols.append(codes); names.append(str(c))
+            else:
+                for lv in cats:
+                    cols.append((s == lv).to_numpy().astype("float32")); names.append(f"{c}={lv}")
+        else:
+            cols.append(pd.to_numeric(s, errors="coerce").to_numpy().astype("float32")); names.append(str(c))
+    return np.column_stack(cols), names
+
+
+def _load_real(name):
+    path = os.path.join(CACHE, f"{name}.npz")
+    if os.path.exists(path):
+        z = np.load(path, allow_pickle=True)
+        return z["X"], z["y"], list(z["names"])
+    from sklearn.datasets import fetch_openml
+    d = fetch_openml(data_id=REAL[name], as_frame=True, parser="auto")
+    X, names = _encode(d.data)
+    classes, y = np.unique(d.target.astype(str).to_numpy(), return_inverse=True)
+    os.makedirs(CACHE, exist_ok=True)
+    np.savez_compressed(path, X=X, y=y, names=np.array(names, dtype=object))
+    return X, y, names
+
+
+def make_synthetic(name, seed=0):
+    from sklearn.datasets import make_classification
+    n, p, n_inf, n_red, clus, heavy, minority, noise = SYN[name]
+    rs = int(name[3:]) * 1000 + seed
+    rng = np.random.default_rng(rs)
+    X, y = make_classification(n_samples=n, n_features=p, n_informative=n_inf, n_redundant=n_red,
+                               n_repeated=0, n_classes=2, n_clusters_per_class=clus,
+                               weights=[1 - minority, minority], flip_y=noise, class_sep=0.9,
+                               shuffle=False, random_state=rs)
+    truth = np.zeros(p, int)
+    truth[:n_inf] = 2
+    truth[n_inf:n_inf + n_red] = 1
+    return _finish(name, X, y, truth, rng, heavy, SYN[name])
+
+
+def _finish(name, X, y, truth, rng, heavy, cfg):
+    """Permuta columnas, escalas heterogéneas, colas pesadas y ruido discreto (común a todos los sintéticos)."""
+    p = X.shape[1]
+    perm = rng.permutation(p)
+    X, truth = X[:, perm].astype("float64"), truth[perm]
+    # escalas heterogéneas (provoca el artefacto de escala observado en ReliefF/MI sin normalizar)
+    X = X * 10 ** rng.uniform(-1, 2, p)
+    if heavy:
+        cols = rng.choice(p, size=int(0.4 * p), replace=False)
+        for j in cols:
+            z = (X[:, j] - X[:, j].mean()) / (X[:, j].std() + 1e-12)
+            X[:, j] = np.sinh(1.8 * z)          # colas pesadas, transformación monótona
+    disc = rng.choice(np.where(truth == 0)[0], size=max(1, int(0.2 * (truth == 0).sum())), replace=False)
+    for j in disc:                                 # ruido discreto (empates / baja cardinalidad)
+        X[:, j] = np.floor(np.clip((X[:, j] - X[:, j].mean()) / (X[:, j].std() + 1e-12) * 2, -4, 4))
+    names = [f"f{j}" for j in range(p)]
+    return Dataset(name, X.astype("float32"), y.astype(int), names, truth,
+                   dict(kind="synthetic", cfg=cfg))
+
+
+def _block_noise(n, p, bs, rho, rng):
+    """p columnas N(0,1) agrupadas en bloques de tamaño bs con correlación intra-bloque rho (modelo de un factor)."""
+    X = rng.normal(size=(n, p))
+    for s in range(0, p, bs):
+        f = rng.normal(size=(n, 1))
+        X[:, s:s + bs] = np.sqrt(rho) * f + np.sqrt(1 - rho) * X[:, s:s + bs]
+    return X
+
+
+def _label(score, minority, noise, rng):
+    s = score + rng.logistic(size=len(score)) * 0.5
+    y = (s > np.quantile(s, 1 - minority)).astype(int)
+    flip = rng.random(len(y)) < noise
+    return np.where(flip, 1 - y, y)
+
+
+def make_synthetic2(name, seed=0):
+    c = SYN2[name]
+    rs = int(name[3:]) * 1000 + seed
+    rng = np.random.default_rng(rs)
+    n, p = c["n"], c["p"]
+    truth = np.zeros(p, int)
+    if c["kind"] == "block":
+        bs = c["block_size"]
+        X = _block_noise(n, p, bs, c["rho"], rng)
+        blocks = rng.choice(p // bs, size=c["n_causal"], replace=False)
+        causal = blocks * bs                                  # primer miembro de cada bloque elegido
+        for b in blocks:
+            truth[b * bs:(b + 1) * bs] = 1                    # el resto del bloque: proxies correlacionados
+        truth[causal] = 2
+        w = rng.choice([-1.0, 1.0], size=len(causal)) * rng.uniform(0.7, 1.3, len(causal))
+        score = X[:, causal] @ w
+        score = score + 0.5 * np.tanh(X[:, causal[0]] * X[:, causal[1]])
+    elif c["kind"] == "xor":
+        X = rng.normal(size=(n, p))
+        npair = c["n_xor"]
+        for j in range(npair):
+            truth[2 * j:2 * j + 2] = 2
+        lin = np.arange(2 * npair, 2 * npair + c["n_lin"])
+        truth[lin] = 2
+        score = sum(2.0 * X[:, 2 * j] * X[:, 2 * j + 1] for j in range(npair)) + X[:, lin].sum(1)
+    elif c["kind"] == "proxy":
+        n_c, ppc = c["n_causal"], c["proxies_per_causal"]
+        X = rng.normal(size=(n, p))
+        rho = c["rho"]
+        for j in range(n_c):
+            for q in range(ppc):
+                col = n_c + j * ppc + q
+                X[:, col] = rho * X[:, j] + np.sqrt(1 - rho ** 2) * X[:, col]
+                truth[col] = 1
+        truth[:n_c] = 2
+        s0 = n_c * (1 + ppc)
+        X[:, s0:] = _block_noise(n, p - s0, c["noise_block"], 0.5, rng)   # ruido que se agrupa en bloques
+        w = rng.choice([-1.0, 1.0], size=n_c) * rng.uniform(0.7, 1.3, n_c)
+        score = np.tanh(X[:, :n_c]) @ w
+    else:
+        raise ValueError(c["kind"])
+    score = (score - score.mean()) / (score.std() + 1e-12) * 1.5
+    y = _label(score, c["minority"], c["noise"], rng)
+    return _finish(name, X, y, truth, rng, c["heavy"], c)
+
+
+def load_dataset(name, max_n=None, seed=0, min_class=10):
+    if name in SYN2:
+        ds = make_synthetic2(name, seed)
+    elif name in SYN:
+        ds = make_synthetic(name, seed)
+    else:
+        X, y, names = _load_real(name)
+        ds = Dataset(name, X, y, names, None, dict(kind="real"))
+    # clases demasiado pequeñas para CV estratificada
+    cnt = np.bincount(ds.y)
+    keep_c = np.where(cnt >= min_class)[0]
+    if len(keep_c) < len(cnt):
+        m = np.isin(ds.y, keep_c)
+        remap = {c: i for i, c in enumerate(keep_c)}
+        ds.X, ds.y = ds.X[m], np.array([remap[v] for v in ds.y[m]])
+    if max_n and len(ds.y) > max_n:
+        from sklearn.model_selection import train_test_split
+        idx, _ = train_test_split(np.arange(len(ds.y)), train_size=max_n, stratify=ds.y, random_state=seed)
+        idx = np.sort(idx)
+        ds.X, ds.y = ds.X[idx], ds.y[idx]
+    ds.meta.update(n=int(ds.X.shape[0]), p=int(ds.X.shape[1]), k=int(ds.y.max() + 1),
+                   minority=float(np.bincount(ds.y).min() / len(ds.y)))
+    return ds
+
+
+def describe(names):
+    rows = []
+    for n in names:
+        d = load_dataset(n)
+        rows.append(dict(dataset=n, **d.meta))
+    import pandas as pd
+    return pd.DataFrame(rows)
+
+
+if __name__ == "__main__":
+    print(describe(list(REAL)[:3]).to_string())
+    json.dumps(TIERS)

decoyfs/bench/models.py

@@ -0,0 +1,225 @@
+"""Downstream evaluation models (GPU when available). Metrics live in :mod:`decoyfs.metrics`."""
+from __future__ import annotations
+
+import warnings
+
+import numpy as np
+import torch
+
+from ..device import device, xgb_device
+from ..metrics import balanced_weights as _bal_weights
+from ..metrics import evaluate, nogueira_stability  # noqa: F401  (re-exported for the benchmark)
+
+
+class LogReg:
+    def __init__(self, seed=0, C=0.5):
+        from sklearn.linear_model import LogisticRegression
+        self.m = LogisticRegression(C=C, max_iter=400, class_weight="balanced")
+
+    def fit(self, X, y):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            self.m.fit(X, y)
+        return self
+
+    def predict_proba(self, X):
+        return self.m.predict_proba(X)
+
+
+class KNNGPU:
+    def __init__(self, seed=0, k=15):
+        self.k = k
+
+    def fit(self, X, y):
+        self.dev = device()
+        self.Xt = torch.as_tensor(X, device=self.dev)
+        self.yt = torch.as_tensor(y, dtype=torch.long, device=self.dev)
+        self.nc = int(y.max()) + 1
+        prior = np.bincount(y, minlength=self.nc) / len(y)
+        self.w = torch.as_tensor(1.0 / np.maximum(prior, 1e-6), dtype=torch.float32, device=self.dev)
+        return self
+
+    def predict_proba(self, X):
+        out, k = [], min(self.k, len(self.yt))
+        T = torch.as_tensor(X, device=self.dev)
+        step = max(64, int(2e7 // max(1, len(self.yt))))
+        for s in range(0, len(T), step):
+            d = torch.cdist(T[s:s + step], self.Xt)
+            dv, di = torch.topk(d, k, dim=1, largest=False)
+            wt = 1.0 / (dv + 1e-3)
+            oh = torch.nn.functional.one_hot(self.yt[di], self.nc).float() * wt[..., None]
+            pr = oh.sum(1) * self.w[None, :] + 1e-3
+            out.append((pr / pr.sum(1, keepdim=True)).cpu().numpy())
+        return np.concatenate(out).astype("float64")
+
+
+class XGB:
+    def __init__(self, seed=0, n_estimators=300, max_depth=5, learning_rate=0.08, colsample_bytree=0.8):
+        import xgboost as xgb
+        self.m = xgb.XGBClassifier(n_estimators=n_estimators, max_depth=max_depth, learning_rate=learning_rate,
+                                   subsample=0.8, colsample_bytree=colsample_bytree, tree_method="hist",
+                                   device=xgb_device(), random_state=seed, n_jobs=4, verbosity=0)
+
+    def fit(self, X, y):
+        self.m.fit(X, y, sample_weight=_bal_weights(y))
+        return self
+
+    def predict_proba(self, X):
+        return self.m.predict_proba(X)
+
+
+class MLP:
+    def __init__(self, seed=0, epochs=60, patience=8, hidden=(256, 128), dropout=0.2, wd=1e-4, lr=2e-3):
+        self.seed, self.epochs, self.patience = seed, epochs, patience
+        self.hidden, self.dropout, self.wd, self.lr = hidden, dropout, wd, lr
+
+    def fit(self, X, y):
+        dev = device()
+        torch.manual_seed(self.seed)
+        n, p = X.shape
+        k = int(y.max()) + 1
+        rng = np.random.default_rng(self.seed)
+        perm = rng.permutation(n)
+        nv = max(int(0.1 * n), 2)
+        va, tr = perm[:nv], perm[nv:]
+        Xt = torch.as_tensor(X, device=dev)
+        yt = torch.as_tensor(y, dtype=torch.long, device=dev)
+        h1, h2 = self.hidden
+        self.net = torch.nn.Sequential(
+            torch.nn.Linear(p, h1), torch.nn.ReLU(), torch.nn.Dropout(self.dropout),
+            torch.nn.Linear(h1, h2), torch.nn.ReLU(), torch.nn.Dropout(self.dropout), torch.nn.Linear(h2, k)).to(dev)
+        cnt = np.bincount(y[tr], minlength=k).clip(min=1)
+        lw = torch.as_tensor(len(tr) / (k * cnt), dtype=torch.float32, device=dev)
+        opt = torch.optim.AdamW(self.net.parameters(), lr=self.lr, weight_decay=self.wd)
+        lossf = torch.nn.CrossEntropyLoss(weight=lw)
+        tr_t = torch.as_tensor(tr, device=dev)
+        va_t = torch.as_tensor(va, device=dev)
+        bs = 256 if n < 5000 else 1024
+        best, bad, state = 1e9, 0, None
+        for _ in range(self.epochs):
+            self.net.train()
+            sh = tr_t[torch.randperm(len(tr_t), device=dev)]
+            for s in range(0, len(sh), bs):
+                b = sh[s:s + bs]
+                opt.zero_grad()
+                lossf(self.net(Xt[b]), yt[b]).backward()
+                opt.step()
+            self.net.eval()
+            with torch.no_grad():
+                vl = lossf(self.net(Xt[va_t]), yt[va_t]).item()
+            if vl < best - 1e-4:
+                best, bad = vl, 0
+                state = {a: v.clone() for a, v in self.net.state_dict().items()}
+            else:
+                bad += 1
+                if bad >= self.patience:
+                    break
+        if state:
+            self.net.load_state_dict(state)
+        self.dev = dev
+        return self
+
+    def predict_proba(self, X):
+        self.net.eval()
+        with torch.no_grad():
+            out = torch.softmax(self.net(torch.as_tensor(X, device=self.dev)), 1)
+        return out.cpu().numpy().astype("float64")
+
+
+class ModelUnavailable(RuntimeError):
+    """Modelo opcional no utilizable (paquete/pesos/licencia): el runner lo desactiva y sigue."""
+
+
+class RealMLP:
+    """RealMLP-TD (Holzmüller et al., 2025) vía pytabkit. Opcional."""
+
+    def __init__(self, seed=0, n_epochs=48, max_rows=10000):
+        self.seed, self.n_epochs, self.max_rows = seed, n_epochs, max_rows
+
+    def fit(self, X, y):
+        try:
+            from pytabkit import RealMLP_TD_Classifier
+        except Exception as e:  # noqa: BLE001
+            raise ModelUnavailable(f"pytabkit no disponible: {repr(e)[:120]}") from e
+        self._k = int(y.max()) + 1
+        if len(y) > self.max_rows:
+            sub = np.random.default_rng(self.seed).choice(len(y), self.max_rows, replace=False)
+            X, y = X[sub], y[sub]
+        self.m = RealMLP_TD_Classifier(device=device(), random_state=self.seed, n_epochs=self.n_epochs, verbosity=0)
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            self.m.fit(X, y)
+        self.classes_ = np.unique(y)
+        return self
+
+    def predict_proba(self, X):
+        P = self.m.predict_proba(X)
+        return _full_proba(P, self.classes_, self._k)
+
+    _k = None
+
+
+def _full_proba(P, classes, k):
+    if k is None or P.shape[1] == k:
+        return P
+    out = np.zeros((P.shape[0], k))
+    out[:, classes] = P
+    return out
+
+
+class Tuned:
+    """Ajusta hiperparámetros con una partición interna (<=4000 filas, estratificada) y reentrena con todo el train.
+
+    Mide la sensibilidad de las conclusiones a los hiperparámetros fijos del protocolo por defecto.
+    """
+    GRIDS = {
+        "logreg": (LogReg, [dict(C=c) for c in (0.05, 0.5, 5.0)]),
+        "knn": (KNNGPU, [dict(k=k) for k in (5, 15, 40)]),
+        "xgb": (XGB, [dict(n_estimators=200, max_depth=3, learning_rate=0.10),
+                      dict(n_estimators=300, max_depth=5, learning_rate=0.08),
+                      dict(n_estimators=400, max_depth=7, learning_rate=0.05),
+                      dict(n_estimators=400, max_depth=4, learning_rate=0.05, colsample_bytree=0.5)]),
+        "mlp": (MLP, [dict(hidden=(256, 128), dropout=0.2, wd=1e-4),
+                      dict(hidden=(128, 64), dropout=0.3, wd=1e-3),
+                      dict(hidden=(512, 256), dropout=0.4, wd=1e-4)]),
+    }
+
+    def __init__(self, base, seed=0, max_rows=4000):
+        self.base, self.seed, self.max_rows = base, seed, max_rows
+
+    def fit(self, X, y):
+        from sklearn.model_selection import train_test_split
+        cls, grid = self.GRIDS[self.base]
+        k = int(y.max()) + 1
+        idx = np.arange(len(y))
+        if len(y) > self.max_rows:
+            idx, _ = train_test_split(idx, train_size=self.max_rows, stratify=y, random_state=self.seed)
+        try:
+            a, b = train_test_split(idx, test_size=0.25, stratify=y[idx], random_state=self.seed)
+        except ValueError:
+            a, b = train_test_split(idx, test_size=0.25, random_state=self.seed)
+        best, best_kw = -np.inf, grid[0]
+        for kw in grid:
+            try:
+                P = cls(self.seed, **kw).fit(X[a], y[a]).predict_proba(X[b])
+                s = evaluate(y[b], P)
+                s = -s["logloss"] if np.isfinite(s.get("logloss", np.nan)) else -np.inf
+            except Exception:  # noqa: BLE001
+                continue
+            if s > best:
+                best, best_kw = s, kw
+        self.best_kw = best_kw
+        self.m = cls(self.seed, **best_kw).fit(X, y)
+        return self
+
+    def predict_proba(self, X):
+        return self.m.predict_proba(X)
+
+
+MODELS = {"logreg": LogReg, "knn": KNNGPU, "xgb": XGB, "mlp": MLP,
+          "logreg_t": lambda s: Tuned("logreg", s), "knn_t": lambda s: Tuned("knn", s),
+          "xgb_t": lambda s: Tuned("xgb", s), "mlp_t": lambda s: Tuned("mlp", s),
+          "realmlp": RealMLP}
+CORE_MODELS = ("logreg", "knn", "xgb", "mlp")
+TUNED_MODELS = ("logreg_t", "knn_t", "xgb_t", "mlp_t")
+FOUNDATION_MODELS = ("realmlp",)

decoyfs/bench/plots.py

@@ -0,0 +1,42 @@
+"""Figuras estándar del protocolo."""
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+def cd_diagram(ranks, cd, ax=None, title="Rangos medios (menor = mejor)"):
+    """Diagrama de diferencia crítica simplificado: barra de rangos y grupos no distinguibles (Nemenyi)."""
+    r = ranks.sort_values()
+    fig, ax = (plt.subplots(figsize=(9, 0.35 * len(r) + 1.5)) if ax is None else (ax.figure, ax))
+    y = np.arange(len(r))[::-1]
+    ax.hlines(y, 0, r.values, color="#9ecae1")
+    ax.plot(r.values, y, "o", color="#08519c")
+    best = r.iloc[0]
+    for yi, (n, v) in zip(y, r.items()):
+        ax.text(v + 0.1, yi, f"{n} ({v:.2f})", va="center", fontsize=8,
+                color="#08519c" if v - best <= cd else "#444")
+    ax.axvline(best + cd, ls="--", c="r", lw=0.8)
+    ax.text(best + cd, y.max() + 0.6, f"mejor + CD={cd:.2f}", color="r", fontsize=8, ha="center")
+    ax.set_yticks([]); ax.set_xlabel("rango medio"); ax.set_title(title)
+    return fig
+
+
+def pareto(tab, metric="auroc_mean", ax=None, ref="ALL"):
+    """Rendimiento vs fracción de atributos retenida."""
+    fig, ax = (plt.subplots(figsize=(7, 5)) if ax is None else (ax.figure, ax))
+    for n, r in tab.iterrows():
+        ctrl = n.startswith("CTRL")
+        ax.scatter(r.frac_feat_median, r[metric], c="#d62728" if ctrl else "#1f77b4", s=45 if ctrl else 30)
+        ax.annotate(n, (r.frac_feat_median, r[metric]), fontsize=7, xytext=(3, 3), textcoords="offset points")
+    ax.set_xlabel("fracción mediana de atributos retenida"); ax.set_ylabel(metric)
+    ax.set_title("Frontera rendimiento vs parsimonia (rojo = referenciadas a controles)")
+    return fig
+
+
+def fpr_bars(sets, ax=None):
+    g = sets.groupby("policy")[["fpr_rand", "fpr_shad"]].mean().sort_values("fpr_shad")
+    fig, ax = (plt.subplots(figsize=(9, 4)) if ax is None else (ax.figure, ax))
+    g.plot.bar(ax=ax, width=0.8)
+    ax.set_ylabel("tasa de controles que 'pasan' (FPR estimada)")
+    ax.set_title("Calibración de falsos positivos con Random / Shadow")
+    ax.tick_params(axis="x", labelsize=7)
+    return fig

decoyfs/bench/presets.py

@@ -0,0 +1,21 @@
+"""Configuración por nivel (compartida por el notebook y run_benchmark.py)."""
+from __future__ import annotations
+
+POL_TUNED = ["ALL", "CTRL_VOTE_MAJ", "FIXK_25", "CVK_1SE", "BORDA_MATCH", "BORUTA", "NABFS"]
+POL_EXT = ["ALL", "CTRL_VOTE_MAJ", "CTRL_BLOCK_VOTE_MAJ", "KO_BORDA_q10", "CVK_1SE", "FIXK_25", "BORUTA", "NABFS"]
+
+# Extensiones que abordan las limitaciones 1-5 (ablaciones, baselines, controles con dependencia, modelos
+# afinados y de fundación). La limitación 6 (max_n) se evalúa con una corrida aparte sobre MAXN_SENS.
+EXT = dict(
+    ablations=True, baselines=["BORUTA", "NABFS"], boruta_iter=25, boruta_budget=240.0, nabfs_boot=20, pass2=True,
+    model_plan=[dict(models=["logreg_t", "knn_t", "xgb_t", "mlp_t"], policies=POL_TUNED, reps=[0], max_p=1000),
+                dict(models=["realmlp"], policies=POL_EXT, reps=[0], max_p=500)],
+)
+
+TIER_CFG = {
+    "smoke": dict(n_splits=3, n_repeats=1, max_n=5000),
+    "laptop": dict(n_splits=5, n_repeats=2, max_n=15000),
+    "full": dict(n_splits=5, n_repeats=2, max_n=15000, stab_B=5, **EXT),
+}
+SENS_MAXN = (3000, 10000)
+SENS_CFG = dict(n_splits=5, n_repeats=2)