decoyfs 0.1.0__tar.gz

decoyfs-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nestor A. Zermeño Campos
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

decoyfs-0.1.0/PKG-INFO

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: decoyfs
+Version: 0.1.0
+Summary: Decoy-referenced feature selection: Random and Shadow control features, swappable rankers and auditable vote policies.
+Author-email: "Nestor A. Zermeño Campos" <nestor.zermeno@uabc.edu.mx>
+License: MIT
+Project-URL: Homepage, https://github.com/alexanderzrm/decoyfs
+Project-URL: Issues, https://github.com/alexanderzrm/decoyfs/issues
+Keywords: feature selection,decoy features,shadow features,random probes,boruta,scikit-learn,tabular
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<3,>=1.26
+Requires-Dist: scipy<2,>=1.11
+Requires-Dist: pandas<3,>=2.0
+Requires-Dist: scikit-learn<2,>=1.4
+Requires-Dist: xgboost<4,>=2.0
+Requires-Dist: torch>=2.2
+Provides-Extra: bench
+Requires-Dist: statsmodels>=0.14; extra == "bench"
+Requires-Dist: matplotlib>=3.8; extra == "bench"
+Requires-Dist: openml>=0.14; extra == "bench"
+Requires-Dist: nbformat>=5.9; extra == "bench"
+Requires-Dist: ipykernel>=6.29; extra == "bench"
+Provides-Extra: bench-extra
+Requires-Dist: pytabkit>=1.5; extra == "bench-extra"
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: ruff>=0.5; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=5; extra == "dev"
+Dynamic: license-file
+
+# DecoyFS
+
+**Decoy-referenced feature selection** for tabular classification. DecoyFS keeps a feature only if it beats *decoys* — columns whose relationship with the target is known to be null — according to several heterogeneous rankers. The result is a small, auditable subset: for every feature you can see which rankers voted for it and how it compared with the decoys.
+
+* **Random probes**: pure-noise columns. A feature must outscore the best probe.
+* **Shadow features**: each real column independently permuted. A feature must outscore the `1 - alpha` quantile of its shadows.
+* **Heterogeneous rankers** (ANOVA, chi², mutual information, ReliefF, random forest, XGBoost gain, L1 logistic regression) vote; a **policy** (`all`, `majority`, `any`, an integer or your own function) turns the votes into the subset.
+* **Every block is swappable**: add or remove rankers, controls and policies. Boruta-style, CV-k and fixed-k comparators are bundled so you can compare on your own data.
+
+> Honest scope. In our benchmark (74 datasets, 5×2 CV, 4 downstream models) DecoyFS is **non-inferior (margin 0.01 AUROC) to using all features and to the comparators**, keeps roughly half of the features (median), is **~10× cheaper than Boruta-style selection** (median time ratio), and is **auditable and tunable** (`policy` moves you along the precision–recall frontier). It does **not** beat Boruta in false-discovery proportion or parsimony; the empirical null-pass rate it reports is a proxy, not a formal FDR guarantee. See the paper for details.
+
+## Install
+
+```bash
+pip install decoyfs            # core (numpy, scipy, pandas, scikit-learn, xgboost, torch)
+pip install "decoyfs[bench]"   # + benchmark harness (OpenML, statsmodels, matplotlib, jupyter)
+```
+
+Python ≥ 3.10. A GPU is optional: if `torch` / `xgboost` can use CUDA they will, otherwise everything runs on CPU. For exactly pinned versions use `benchmarks/requirements-lock.txt` (tested on Python 3.11).
+
+## Quick start
+
+```python
+from decoyfs import DecoySelector
+
+sel = DecoySelector(policy="majority", alpha=0.05, random_state=0).fit(X_train, y_train)
+X_small = sel.transform(X_test)
+
+sel.selected_features_      # names (DataFrame input) or column indices
+sel.report_                 # per-feature audit trail: votes, beat_random / beat_shadow fractions, per-ranker scores
+sel.decoy_thresholds_       # the bar each ranker set (Random max, Shadow quantile)
+sel.null_pass_rate_         # fraction of decoys that would have been selected (empirical FPR proxy)
+```
+
+It is a scikit-learn transformer, so it works in a `Pipeline`:
+
+```python
+from sklearn.pipeline import make_pipeline
+from sklearn.linear_model import LogisticRegression
+model = make_pipeline(DecoySelector(), LogisticRegression(max_iter=500)).fit(X_train, y_train)
+```
+
+### Choose your trade-off
+
+| `policy` | Rule | Use when |
+|---|---|---|
+| `"all"` | every ranker must beat the decoys | precision first (few false features) |
+| `"majority"` | at least half of the rankers (reference) | balanced default |
+| `"any"` | at least one ranker | recall first, e.g. you must not lose a critical signal (screening, quality control) |
+| `3` | at least 3 rankers | custom |
+| callable | `(votes, n_rankers, consensus) -> indices` | anything else |
+
+`stability_B=5` adds a subsampling stability filter; `controls=("random", "block")` replaces Shadow by Block-Shadow for strongly correlated features.
+
+### Swap the pieces
+
+```python
+import numpy as np
+from decoyfs import register_ranker, register_policy, DecoySelector, list_rankers
+
+register_ranker("mean_gap", lambda X, y: np.abs(X[y == 1].mean(0) - X[y == 0].mean(0)))
+register_policy("top10", lambda votes, M, consensus: np.argsort(-consensus)[:10])
+
+DecoySelector(rankers=("anova", "rf", "mean_gap"), policy="top10").fit(X, y)
+```
+
+A ranker is any function `fn(X, y) -> one score per column` (higher = more relevant). See [docs/extending.md](docs/extending.md) and the block diagram in [docs/architecture.md](docs/architecture.md).
+
+### Compare with other selectors on your data
+
+```python
+from decoyfs import DecoySelector, FixedKSelector, CVKSelector, BorutaSelector, compare_selectors
+
+df = compare_selectors(X, y, {
+    "all": None,
+    "decoyfs": DecoySelector(),
+    "fixed25": FixedKSelector(k=0.25),
+    "cvk_1se": CVKSelector(),
+    "boruta_style": BorutaSelector(),
+}, model="xgb", cv=5)
+df.groupby("selector").mean(numeric_only=True)
+```
+
+`BorutaSelector` is a **Boruta-style re-implementation** (XGBoost gain importance, shadow features, binomial test with Bonferroni correction), the one used in the paper. It is not the `BorutaPy` package.
+
+## Input rules
+
+Failing early beats failing silently. DecoyFS raises `DecoyInputError` with an actionable message when:
+
+* `X` is not numeric (encode categoricals first), is not 2-D, or contains `±inf` (NaN is allowed: median imputation is applied inside the selector);
+* `y` is not 1-D, has missing values, looks continuous (regression is not supported), or has fewer than 2 classes or fewer than 5 samples in a class;
+* there are fewer than 20 rows or fewer than 2 columns; feature names are duplicated;
+* `transform` receives different columns than `fit` (count or names).
+
+Constant columns are dropped (reported with `NaN` in `report_`). If a policy returns an empty set, the 3 top-consensus features are returned with a warning (`fallback_ = True`).
+
+## GPU
+
+The rankers and the downstream models in the benchmark use `torch` / `xgboost` on CUDA when available (`decoyfs.device.env_report()` shows what was detected). On NVIDIA Blackwell cards (RTX 50xx) install a CUDA 12.8 build of torch: `pip install torch --index-url https://download.pytorch.org/whl/cu128`.
+
+## Reproduce the paper
+
+```bash
+git clone <this repo> && cd decoyfs
+pip install -e ".[bench]"
+python benchmarks/build_notebook.py        # creates benchmarks/notebooks/DecoyFS_benchmark.ipynb
+python benchmarks/run_benchmark.py --tier smoke          # minutes
+python benchmarks/run_benchmark.py --tier full --force-gpu   # 74 datasets, 5x2 CV (about 23 h on an RTX 5060 Ti)
+python benchmarks/analysis/decoy_vs_comparators.py        # paired comparison vs Boruta-style and CV-k
+```
+
+Datasets are downloaded from OpenML into `~/.cache/decoyfs` (override with `DECOYFS_CACHE`). The benchmark's policy identifiers (`CTRL_VOTE_MAJ`, `CTRL_STAB`, `BORUTA`, `CVK_1SE`, …) are kept as in the released result tables. The Spanish protocol design document is in [docs/DISENO_PROTOCOLO.es.md](docs/DISENO_PROTOCOLO.es.md).
+
+## Cite
+
+See [CITATION.cff](CITATION.cff). A software DOI is minted by Zenodo for every release.
+
+## License
+
+MIT © Nestor A. Zermeño Campos, Universidad Autónoma de Baja California.

decoyfs-0.1.0/README.md

@@ -0,0 +1,120 @@
+# DecoyFS
+
+**Decoy-referenced feature selection** for tabular classification. DecoyFS keeps a feature only if it beats *decoys* — columns whose relationship with the target is known to be null — according to several heterogeneous rankers. The result is a small, auditable subset: for every feature you can see which rankers voted for it and how it compared with the decoys.
+
+* **Random probes**: pure-noise columns. A feature must outscore the best probe.
+* **Shadow features**: each real column independently permuted. A feature must outscore the `1 - alpha` quantile of its shadows.
+* **Heterogeneous rankers** (ANOVA, chi², mutual information, ReliefF, random forest, XGBoost gain, L1 logistic regression) vote; a **policy** (`all`, `majority`, `any`, an integer or your own function) turns the votes into the subset.
+* **Every block is swappable**: add or remove rankers, controls and policies. Boruta-style, CV-k and fixed-k comparators are bundled so you can compare on your own data.
+
+> Honest scope. In our benchmark (74 datasets, 5×2 CV, 4 downstream models) DecoyFS is **non-inferior (margin 0.01 AUROC) to using all features and to the comparators**, keeps roughly half of the features (median), is **~10× cheaper than Boruta-style selection** (median time ratio), and is **auditable and tunable** (`policy` moves you along the precision–recall frontier). It does **not** beat Boruta in false-discovery proportion or parsimony; the empirical null-pass rate it reports is a proxy, not a formal FDR guarantee. See the paper for details.
+
+## Install
+
+```bash
+pip install decoyfs            # core (numpy, scipy, pandas, scikit-learn, xgboost, torch)
+pip install "decoyfs[bench]"   # + benchmark harness (OpenML, statsmodels, matplotlib, jupyter)
+```
+
+Python ≥ 3.10. A GPU is optional: if `torch` / `xgboost` can use CUDA they will, otherwise everything runs on CPU. For exactly pinned versions use `benchmarks/requirements-lock.txt` (tested on Python 3.11).
+
+## Quick start
+
+```python
+from decoyfs import DecoySelector
+
+sel = DecoySelector(policy="majority", alpha=0.05, random_state=0).fit(X_train, y_train)
+X_small = sel.transform(X_test)
+
+sel.selected_features_      # names (DataFrame input) or column indices
+sel.report_                 # per-feature audit trail: votes, beat_random / beat_shadow fractions, per-ranker scores
+sel.decoy_thresholds_       # the bar each ranker set (Random max, Shadow quantile)
+sel.null_pass_rate_         # fraction of decoys that would have been selected (empirical FPR proxy)
+```
+
+It is a scikit-learn transformer, so it works in a `Pipeline`:
+
+```python
+from sklearn.pipeline import make_pipeline
+from sklearn.linear_model import LogisticRegression
+model = make_pipeline(DecoySelector(), LogisticRegression(max_iter=500)).fit(X_train, y_train)
+```
+
+### Choose your trade-off
+
+| `policy` | Rule | Use when |
+|---|---|---|
+| `"all"` | every ranker must beat the decoys | precision first (few false features) |
+| `"majority"` | at least half of the rankers (reference) | balanced default |
+| `"any"` | at least one ranker | recall first, e.g. you must not lose a critical signal (screening, quality control) |
+| `3` | at least 3 rankers | custom |
+| callable | `(votes, n_rankers, consensus) -> indices` | anything else |
+
+`stability_B=5` adds a subsampling stability filter; `controls=("random", "block")` replaces Shadow by Block-Shadow for strongly correlated features.
+
+### Swap the pieces
+
+```python
+import numpy as np
+from decoyfs import register_ranker, register_policy, DecoySelector, list_rankers
+
+register_ranker("mean_gap", lambda X, y: np.abs(X[y == 1].mean(0) - X[y == 0].mean(0)))
+register_policy("top10", lambda votes, M, consensus: np.argsort(-consensus)[:10])
+
+DecoySelector(rankers=("anova", "rf", "mean_gap"), policy="top10").fit(X, y)
+```
+
+A ranker is any function `fn(X, y) -> one score per column` (higher = more relevant). See [docs/extending.md](docs/extending.md) and the block diagram in [docs/architecture.md](docs/architecture.md).
+
+### Compare with other selectors on your data
+
+```python
+from decoyfs import DecoySelector, FixedKSelector, CVKSelector, BorutaSelector, compare_selectors
+
+df = compare_selectors(X, y, {
+    "all": None,
+    "decoyfs": DecoySelector(),
+    "fixed25": FixedKSelector(k=0.25),
+    "cvk_1se": CVKSelector(),
+    "boruta_style": BorutaSelector(),
+}, model="xgb", cv=5)
+df.groupby("selector").mean(numeric_only=True)
+```
+
+`BorutaSelector` is a **Boruta-style re-implementation** (XGBoost gain importance, shadow features, binomial test with Bonferroni correction), the one used in the paper. It is not the `BorutaPy` package.
+
+## Input rules
+
+Failing early beats failing silently. DecoyFS raises `DecoyInputError` with an actionable message when:
+
+* `X` is not numeric (encode categoricals first), is not 2-D, or contains `±inf` (NaN is allowed: median imputation is applied inside the selector);
+* `y` is not 1-D, has missing values, looks continuous (regression is not supported), or has fewer than 2 classes or fewer than 5 samples in a class;
+* there are fewer than 20 rows or fewer than 2 columns; feature names are duplicated;
+* `transform` receives different columns than `fit` (count or names).
+
+Constant columns are dropped (reported with `NaN` in `report_`). If a policy returns an empty set, the 3 top-consensus features are returned with a warning (`fallback_ = True`).
+
+## GPU
+
+The rankers and the downstream models in the benchmark use `torch` / `xgboost` on CUDA when available (`decoyfs.device.env_report()` shows what was detected). On NVIDIA Blackwell cards (RTX 50xx) install a CUDA 12.8 build of torch: `pip install torch --index-url https://download.pytorch.org/whl/cu128`.
+
+## Reproduce the paper
+
+```bash
+git clone <this repo> && cd decoyfs
+pip install -e ".[bench]"
+python benchmarks/build_notebook.py        # creates benchmarks/notebooks/DecoyFS_benchmark.ipynb
+python benchmarks/run_benchmark.py --tier smoke          # minutes
+python benchmarks/run_benchmark.py --tier full --force-gpu   # 74 datasets, 5x2 CV (about 23 h on an RTX 5060 Ti)
+python benchmarks/analysis/decoy_vs_comparators.py        # paired comparison vs Boruta-style and CV-k
+```
+
+Datasets are downloaded from OpenML into `~/.cache/decoyfs` (override with `DECOYFS_CACHE`). The benchmark's policy identifiers (`CTRL_VOTE_MAJ`, `CTRL_STAB`, `BORUTA`, `CVK_1SE`, …) are kept as in the released result tables. The Spanish protocol design document is in [docs/DISENO_PROTOCOLO.es.md](docs/DISENO_PROTOCOLO.es.md).
+
+## Cite
+
+See [CITATION.cff](CITATION.cff). A software DOI is minted by Zenodo for every release.
+
+## License
+
+MIT © Nestor A. Zermeño Campos, Universidad Autónoma de Baja California.

decoyfs-0.1.0/pyproject.toml

@@ -0,0 +1,68 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "decoyfs"
+dynamic = ["version"]
+description = "Decoy-referenced feature selection: Random and Shadow control features, swappable rankers and auditable vote policies."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Nestor A. Zermeño Campos", email = "nestor.zermeno@uabc.edu.mx" }]
+keywords = ["feature selection", "decoy features", "shadow features", "random probes", "boruta", "scikit-learn", "tabular"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "numpy>=1.26,<3",
+    "scipy>=1.11,<2",
+    "pandas>=2.0,<3",
+    "scikit-learn>=1.4,<2",
+    "xgboost>=2.0,<4",
+    "torch>=2.2",
+]
+
+[project.optional-dependencies]
+bench = [
+    "statsmodels>=0.14",
+    "matplotlib>=3.8",
+    "openml>=0.14",
+    "nbformat>=5.9",
+    "ipykernel>=6.29",
+]
+bench-extra = ["pytabkit>=1.5"]
+dev = ["pytest>=8", "ruff>=0.5", "build>=1.2", "twine>=5"]
+
+[project.urls]
+Homepage = "https://github.com/alexanderzrm/decoyfs"
+Issues = "https://github.com/alexanderzrm/decoyfs/issues"
+
+[tool.setuptools.dynamic]
+version = { attr = "decoyfs.__version__" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+decoyfs = ["py.typed"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-q"
+filterwarnings = ["ignore::DeprecationWarning"]
+
+[tool.ruff]
+line-length = 120
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "W"]
+ignore = ["E501", "E702", "E731", "E741", "F841"]

decoyfs-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

decoyfs-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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]"``.
+"""