trexselector 0.6.0__tar.gz

trexselector-0.6.0/PKG-INFO

@@ -0,0 +1,84 @@
+Metadata-Version: 2.2
+Name: trexselector
+Version: 0.6.0
+Summary: T-Rex Selector: High-Dimensional Variable Selection & FDR Control
+Home-page: https://github.com/ArnauVilella/trexselector-python
+Author: Python port by Arnau Vilella
+Author-email: avp@connect.ust.hk
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: scikit-learn
+Requires-Dist: tlars
+Requires-Dist: joblib
+Requires-Dist: matplotlib
+Requires-Dist: pandas
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# TRexSelector-Python (trexselector)
+
+A Python port of the [TRexSelector](https://github.com/jasinmachkour/TRexSelector) R package for high-dimensional variable selection with false discovery rate (FDR) control.
+
+## Overview
+
+TRexSelector performs fast variable selection in high-dimensional settings while controlling the false discovery rate (FDR) at a user-defined target level. The package is based on the paper [Machkour, Muma, and Palomar (2022)](https://arxiv.org/abs/2110.06048).
+
+This Python package provides a port of the original R implementation, maintaining the same functionality while providing a more Pythonic interface. The Python port was created by Arnau Vilella (avp@connect.ust.hk).
+
+## Installation
+
+```bash
+pip install trexselector==0.6.0
+```
+
+## Usage
+
+```python
+import numpy as np
+from trexselector import trex, generate_gaussian_data
+
+# Generate some example data
+X, y, beta = generate_gaussian_data(n=100, p=20, seed=1234)
+
+# Run the T-Rex selector
+res = trex(X=X, y=y)
+
+# Get the selected variables
+selected_var = res["selected_var"]
+print(f"Selected variables: {selected_var}")
+```
+
+## Functions
+
+The package contains the following main functions:
+
+- `trex`: The main function for the T-Rex selector, which performs variable selection while controlling the FDR
+- `screen_trex`: A screening variant of the T-Rex selector for ultra-high dimensional datasets
+- `random_experiments`: Run K random experiments with the T-Rex selector
+- `add_dummies`, `add_dummies_GVS`: Helper functions for adding dummy variables 
+- `FDP`, `TPP`: Functions for computing false discovery and true positive proportions
+
+## References
+
+- Machkour, J., Muma, M., & Palomar, D. P. (2022). Model-Free Variable Selection with Directed Controls for the False Discovery Rate via Coefficient of Intrinsic Dependence. arXiv preprint arXiv:2110.06048.
+- Machkour, J., Muma, M., & Palomar, D. P. (2022). High-dimensional variable selection for classification via binary random sketching. 2022 30th European Signal Processing Conference (EUSIPCO), 2202-2206.
+
+## License
+
+This package is licensed under the GNU General Public License v3.0 (GPL-3.0).
+
+## Acknowledgments
+
+The original R package [TRexSelector](https://github.com/jasinmachkour/TRexSelector) was created by Jasin Machkour, Simon Tien, Daniel P. Palomar, and Michael Muma. This Python port was developed by Arnau Vilella (avp@connect.ust.hk).

trexselector-0.6.0/README.md

@@ -0,0 +1,55 @@
+# TRexSelector-Python (trexselector)
+
+A Python port of the [TRexSelector](https://github.com/jasinmachkour/TRexSelector) R package for high-dimensional variable selection with false discovery rate (FDR) control.
+
+## Overview
+
+TRexSelector performs fast variable selection in high-dimensional settings while controlling the false discovery rate (FDR) at a user-defined target level. The package is based on the paper [Machkour, Muma, and Palomar (2022)](https://arxiv.org/abs/2110.06048).
+
+This Python package provides a port of the original R implementation, maintaining the same functionality while providing a more Pythonic interface. The Python port was created by Arnau Vilella (avp@connect.ust.hk).
+
+## Installation
+
+```bash
+pip install trexselector==0.6.0
+```
+
+## Usage
+
+```python
+import numpy as np
+from trexselector import trex, generate_gaussian_data
+
+# Generate some example data
+X, y, beta = generate_gaussian_data(n=100, p=20, seed=1234)
+
+# Run the T-Rex selector
+res = trex(X=X, y=y)
+
+# Get the selected variables
+selected_var = res["selected_var"]
+print(f"Selected variables: {selected_var}")
+```
+
+## Functions
+
+The package contains the following main functions:
+
+- `trex`: The main function for the T-Rex selector, which performs variable selection while controlling the FDR
+- `screen_trex`: A screening variant of the T-Rex selector for ultra-high dimensional datasets
+- `random_experiments`: Run K random experiments with the T-Rex selector
+- `add_dummies`, `add_dummies_GVS`: Helper functions for adding dummy variables 
+- `FDP`, `TPP`: Functions for computing false discovery and true positive proportions
+
+## References
+
+- Machkour, J., Muma, M., & Palomar, D. P. (2022). Model-Free Variable Selection with Directed Controls for the False Discovery Rate via Coefficient of Intrinsic Dependence. arXiv preprint arXiv:2110.06048.
+- Machkour, J., Muma, M., & Palomar, D. P. (2022). High-dimensional variable selection for classification via binary random sketching. 2022 30th European Signal Processing Conference (EUSIPCO), 2202-2206.
+
+## License
+
+This package is licensed under the GNU General Public License v3.0 (GPL-3.0).
+
+## Acknowledgments
+
+The original R package [TRexSelector](https://github.com/jasinmachkour/TRexSelector) was created by Jasin Machkour, Simon Tien, Daniel P. Palomar, and Michael Muma. This Python port was developed by Arnau Vilella (avp@connect.ust.hk).

trexselector-0.6.0/setup.cfg

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

trexselector-0.6.0/setup.py

@@ -0,0 +1,31 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="trexselector",
+    version="0.6.0",
+    author="Python port by Arnau Vilella",
+    author_email="avp@connect.ust.hk",
+    description="T-Rex Selector: High-Dimensional Variable Selection & FDR Control",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/ArnauVilella/trexselector-python",
+    packages=find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.8",
+    install_requires=[
+        "numpy",
+        "scipy",
+        "scikit-learn",
+        "tlars",
+        "joblib",
+        "matplotlib",
+        "pandas"
+    ],
+)

trexselector-0.6.0/tests/conftest.py

@@ -0,0 +1,46 @@
+"""
+Pytest configuration file.
+"""
+
+import os
+import sys
+import pytest
+import numpy as np
+
+# Add the package root to the Python path
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+@pytest.fixture
+def gaussian_data():
+    """
+    Fixture providing Gaussian test data similar to the R package's Gauss_data.
+    
+    Returns:
+        tuple: X, y, beta where:
+            X is the predictor matrix (n x p)
+            y is the response vector (n)
+            beta is the true coefficient vector (p)
+    """
+    # Set seed for reproducibility
+    np.random.seed(789)
+    
+    n, p = 50, 100
+    
+    # Generate predictor matrix
+    X = np.random.normal(0, 1, size=(n, p))
+    
+    # Scale X
+    X = (X - X.mean(axis=0)) / X.std(axis=0, ddof=1)
+    
+    # Generate true coefficient vector (3 non-zero coefficients)
+    beta = np.zeros(p)
+    beta[:3] = 3.0
+    
+    # Generate response vector
+    eps = np.random.normal(0, 1, size=n)
+    y = X @ beta + eps
+    
+    # Center y
+    y = y - y.mean()
+    
+    return X, y, beta 

trexselector-0.6.0/tests/test_trexselector/__init__.py

@@ -0,0 +1,3 @@
+"""
+Test package for trexselector.
+""" 

trexselector-0.6.0/tests/test_trexselector/test_add_dummies.py

@@ -0,0 +1,60 @@
+"""
+Tests for the add_dummies function.
+"""
+
+import pytest
+import numpy as np
+from trexselector import add_dummies
+
+def test_add_dummies_input_validation(gaussian_data):
+    """Test error control for inputs X and num_dummies."""
+    X, y, _ = gaussian_data
+    
+    # Tests for X
+    # Test X must be a 2D array
+    with pytest.raises(ValueError, match="'X' must be a 2D numpy array"):
+        add_dummies(X=X[:, 0], num_dummies=10)
+    
+    # Create X with NaNs
+    X_with_nan = X.copy()
+    X_with_nan[0, 0] = np.nan
+    
+    with pytest.raises(ValueError, match="'X' contains NaNs"):
+        add_dummies(X=X_with_nan, num_dummies=10)
+    
+    # Tests for num_dummies
+    # Test num_dummies must be an integer
+    with pytest.raises(ValueError, match="'num_dummies' must be an integer larger or equal to 1"):
+        add_dummies(X=X, num_dummies=0.5)
+    
+    # Test num_dummies must be >= 1
+    with pytest.raises(ValueError, match="'num_dummies' must be an integer larger or equal to 1"):
+        add_dummies(X=X, num_dummies=0)
+    
+    # Test num_dummies must not be negative
+    with pytest.raises(ValueError, match="'num_dummies' must be an integer larger or equal to 1"):
+        add_dummies(X=X, num_dummies=-10)
+
+def test_add_dummies_output_shape(gaussian_data):
+    """Test that the output shape of add_dummies is correct."""
+    X, _, _ = gaussian_data
+    
+    # Create a smaller test matrix
+    n, p = 20, 5
+    np.random.seed(42)
+    X_small = np.random.randn(n, p)
+    
+    # Test with different numbers of dummies
+    for num_dummies in [1, 2, 3]:
+        X_Dummy = add_dummies(X=X_small, num_dummies=num_dummies)
+        
+        # Check shape
+        assert X_Dummy.shape == (n, p + num_dummies), f"Expected shape {(n, p + num_dummies)}, got {X_Dummy.shape}"
+        
+        # Check that the first p columns are identical to X
+        np.testing.assert_allclose(X_Dummy[:, :p], X_small)
+        
+        # Check that the dummy variables are standardized with more tolerance
+        for j in range(p, p + num_dummies):
+            assert abs(X_Dummy[:, j].mean()) < 1e-10, f"Dummy column {j} is not centered"
+            assert abs(X_Dummy[:, j].std() - 1.0) < 1e-10, f"Dummy column {j} is not standardized" 

trexselector-0.6.0/tests/test_trexselector/test_fdp.py

@@ -0,0 +1,81 @@
+"""
+Tests for the FDP (False Discovery Proportion) function.
+"""
+
+import pytest
+import numpy as np
+from trexselector import FDP, trex
+
+def test_fdp_input_validation_beta_hat(gaussian_data):
+    """Test error control for input beta_hat."""
+    X, y, beta = gaussian_data
+    
+    # Run T-Rex to get beta_hat
+    np.random.seed(1234)
+    res = trex(X, y, verbose=False)
+    beta_hat = np.zeros(beta.shape[0])
+    beta_hat[res["selected_var"]] = 1
+    
+    # Create beta_hat with NAs
+    beta_hat_with_nan = beta_hat.copy()
+    beta_hat_with_nan[np.random.choice(len(beta_hat), size=10)] = np.nan
+    
+    # Tests
+    # Test beta_hat must be 1D array
+    with pytest.raises(ValueError, match="'beta_hat' must be a 1D numpy array"):
+        FDP(beta_hat=np.column_stack([beta_hat, beta_hat]), beta=beta)
+    
+    # Test beta_hat must be numeric
+    with pytest.raises(ValueError, match="'beta_hat' must be a 1D numpy array"):
+        FDP(beta_hat=beta_hat.astype(str), beta=beta)
+    
+    # Test beta_hat cannot contain NaNs
+    with pytest.raises(ValueError, match="'beta_hat' contains NaNs"):
+        FDP(beta_hat=beta_hat_with_nan, beta=beta)
+
+def test_fdp_input_validation_beta(gaussian_data):
+    """Test error control for input beta."""
+    X, y, beta = gaussian_data
+    
+    # Run T-Rex to get beta_hat
+    np.random.seed(1234)
+    res = trex(X, y, verbose=False)
+    beta_hat = np.zeros(beta.shape[0])
+    beta_hat[res["selected_var"]] = 1
+    
+    # Create beta with NAs
+    beta_with_nan = beta.copy()
+    beta_with_nan[np.random.choice(len(beta), size=10)] = np.nan
+    
+    # Tests
+    # Test beta must be 1D array
+    with pytest.raises(ValueError, match="'beta' must be a 1D numpy array"):
+        FDP(beta_hat=beta_hat, beta=np.column_stack([beta, beta]))
+    
+    # Test beta must be numeric
+    with pytest.raises(ValueError, match="'beta' must be a 1D numpy array"):
+        FDP(beta_hat=beta_hat, beta=beta.astype(str))
+    
+    # Test beta cannot contain NaNs
+    with pytest.raises(ValueError, match="'beta' contains NaNs"):
+        FDP(beta_hat=beta_hat, beta=beta_with_nan)
+    
+    # Test length of beta_hat must match length of beta
+    with pytest.raises(ValueError, match="Shapes of 'beta_hat' and 'beta' must match"):
+        FDP(beta_hat=np.concatenate([beta_hat, beta_hat]), beta=beta)
+
+def test_fdp_value_range(gaussian_data):
+    """Test that the value of FDP is in the interval [0, 1]."""
+    X, y, beta = gaussian_data
+    
+    # Run T-Rex to get beta_hat
+    np.random.seed(1234)
+    res = trex(X, y, verbose=False)
+    beta_hat = np.zeros(beta.shape[0])
+    beta_hat[res["selected_var"]] = 1
+    
+    # Compute FDP
+    fdp = FDP(beta_hat=beta_hat, beta=beta)
+    
+    # Test FDP is in [0, 1]
+    assert 0 <= fdp <= 1, f"FDP value {fdp} is outside the expected range [0, 1]" 

trexselector-0.6.0/tests/test_trexselector/test_tpp.py

@@ -0,0 +1,81 @@
+"""
+Tests for the TPP (True Positive Proportion) function.
+"""
+
+import pytest
+import numpy as np
+from trexselector import TPP, trex
+
+def test_tpp_input_validation_beta_hat(gaussian_data):
+    """Test error control for input beta_hat."""
+    X, y, beta = gaussian_data
+    
+    # Run T-Rex to get beta_hat
+    np.random.seed(1234)
+    res = trex(X, y, verbose=False)
+    beta_hat = np.zeros(beta.shape[0])
+    beta_hat[res["selected_var"]] = 1
+    
+    # Create beta_hat with NAs
+    beta_hat_with_nan = beta_hat.copy()
+    beta_hat_with_nan[np.random.choice(len(beta_hat), size=10)] = np.nan
+    
+    # Tests
+    # Test beta_hat must be 1D array
+    with pytest.raises(ValueError, match="'beta_hat' must be a 1D numpy array"):
+        TPP(beta_hat=np.column_stack([beta_hat, beta_hat]), beta=beta)
+    
+    # Test beta_hat must be numeric
+    with pytest.raises(ValueError, match="'beta_hat' must be a 1D numpy array"):
+        TPP(beta_hat=beta_hat.astype(str), beta=beta)
+    
+    # Test beta_hat cannot contain NaNs
+    with pytest.raises(ValueError, match="'beta_hat' contains NaNs"):
+        TPP(beta_hat=beta_hat_with_nan, beta=beta)
+
+def test_tpp_input_validation_beta(gaussian_data):
+    """Test error control for input beta."""
+    X, y, beta = gaussian_data
+    
+    # Run T-Rex to get beta_hat
+    np.random.seed(1234)
+    res = trex(X, y, verbose=False)
+    beta_hat = np.zeros(beta.shape[0])
+    beta_hat[res["selected_var"]] = 1
+    
+    # Create beta with NAs
+    beta_with_nan = beta.copy()
+    beta_with_nan[np.random.choice(len(beta), size=10)] = np.nan
+    
+    # Tests
+    # Test beta must be 1D array
+    with pytest.raises(ValueError, match="'beta' must be a 1D numpy array"):
+        TPP(beta_hat=beta_hat, beta=np.column_stack([beta, beta]))
+    
+    # Test beta must be numeric
+    with pytest.raises(ValueError, match="'beta' must be a 1D numpy array"):
+        TPP(beta_hat=beta_hat, beta=beta.astype(str))
+    
+    # Test beta cannot contain NaNs
+    with pytest.raises(ValueError, match="'beta' contains NaNs"):
+        TPP(beta_hat=beta_hat, beta=beta_with_nan)
+    
+    # Test length of beta_hat must match length of beta
+    with pytest.raises(ValueError, match="Shapes of 'beta_hat' and 'beta' must match"):
+        TPP(beta_hat=np.concatenate([beta_hat, beta_hat]), beta=beta)
+
+def test_tpp_value_range(gaussian_data):
+    """Test that the value of TPP is in the interval [0, 1]."""
+    X, y, beta = gaussian_data
+    
+    # Run T-Rex to get beta_hat
+    np.random.seed(1234)
+    res = trex(X, y, verbose=False)
+    beta_hat = np.zeros(beta.shape[0])
+    beta_hat[res["selected_var"]] = 1
+    
+    # Compute TPP
+    tpp = TPP(beta_hat=beta_hat, beta=beta)
+    
+    # Test TPP is in [0, 1]
+    assert 0 <= tpp <= 1, f"TPP value {tpp} is outside the expected range [0, 1]" 

trexselector-0.6.0/tests/test_trexselector/test_trex.py

@@ -0,0 +1,103 @@
+"""
+Tests for the main trex function.
+"""
+
+import pytest
+import numpy as np
+from trexselector import trex
+
+def test_trex_input_validation_method_type(gaussian_data):
+    """Test error control for inputs method and type."""
+    X, y, _ = gaussian_data
+    
+    # Test method must be one of the allowed values
+    with pytest.raises(ValueError, match="'method' must be one of"):
+        trex(X=X, y=y, method="test")
+    
+    # Test type must be one of the allowed values
+    with pytest.raises(ValueError, match="'type' must be one of"):
+        trex(X=X, y=y, type="test")
+
+def test_trex_input_validation_X(gaussian_data):
+    """Test error control for input X."""
+    X, y, _ = gaussian_data
+    
+    # Test X must be a 2D array
+    with pytest.raises(ValueError, match="'X' must be a 2D numpy array"):
+        trex(X=X[:, 0], y=y)
+    
+    # Create X with NaNs
+    X_with_nan = X.copy()
+    X_with_nan[0, 0] = np.nan
+    
+    with pytest.raises(ValueError, match="'X' contains NaNs"):
+        trex(X=X_with_nan, y=y)
+    
+    # Test X with non-numeric values - this will either raise when creating the X array
+    # or during standardization, so we just check for any ValueError
+    with pytest.raises(Exception):
+        trex(X=X.astype(str), y=y)
+
+def test_trex_input_validation_y(gaussian_data):
+    """Test error control for input y."""
+    X, y, _ = gaussian_data
+    
+    # Test y must be a 1D array
+    with pytest.raises(ValueError, match="'y' must be a 1D numpy array"):
+        trex(X=X, y=np.column_stack([y, y]))
+    
+    # Create y with NaNs
+    y_with_nan = y.copy()
+    y_with_nan[0] = np.nan
+    
+    # Check for a ValueError with a message containing "NaN" (case insensitive)
+    with pytest.raises(ValueError, match="NaN"):
+        trex(X=X, y=y_with_nan)
+    
+    # Test X and y must have compatible shapes
+    with pytest.raises(ValueError, match="Number of rows in X must match length of y"):
+        trex(X=X, y=y[:-1])
+
+def test_trex_input_validation_parameters(gaussian_data):
+    """Test error control for other parameters."""
+    X, y, _ = gaussian_data
+    
+    # Test tFDR must be between 0 and 1
+    with pytest.raises(ValueError, match="'tFDR' must be a number between 0 and 1"):
+        trex(X=X, y=y, tFDR=-0.1)
+    
+    with pytest.raises(ValueError, match="'tFDR' must be a number between 0 and 1"):
+        trex(X=X, y=y, tFDR=1.1)
+    
+    # Test K must be >= 2
+    with pytest.raises(ValueError, match="The number of random experiments 'K' must be an integer larger or equal to 2"):
+        trex(X=X, y=y, K=1)
+    
+    # Test max_num_dummies must be >= 1
+    with pytest.raises(ValueError, match="'max_num_dummies' must be an integer larger or equal to 1"):
+        trex(X=X, y=y, max_num_dummies=0)
+
+def test_trex_basic_functionality(gaussian_data):
+    """Test that trex produces the expected output."""
+    X, y, beta = gaussian_data
+    
+    # Run trex with minimal parameters
+    np.random.seed(1234)
+    res = trex(X=X, y=y, tFDR=0.2, K=5, max_num_dummies=1, verbose=False)
+    
+    # Check that the output contains the expected keys
+    expected_keys = [
+        "selected_var", "tFDR", "T_stop", "num_dummies", "V", "v_thresh"
+    ]
+    for key in expected_keys:
+        assert key in res, f"Expected key {key} not found in result"
+    
+    # Check that selected_var is a numpy array
+    assert isinstance(res["selected_var"], np.ndarray), "selected_var should be a numpy array"
+    
+    # Check that T_stop is a positive integer
+    assert isinstance(res["T_stop"], int), "T_stop should be an integer"
+    assert res["T_stop"] > 0, "T_stop should be positive"
+    
+    # Check that the number of dummies is as expected
+    assert res["num_dummies"] == X.shape[1], "num_dummies should be p in the first iteration" 

trexselector-0.6.0/trexselector/__init__.py

@@ -0,0 +1,19 @@
+"""
+TRexSelector: T-Rex Selector for High-Dimensional Variable Selection & FDR Control
+
+This package performs fast variable selection in high-dimensional settings while 
+controlling the false discovery rate (FDR) at a user-defined target level.
+"""
+
+from .trex import trex
+from .random_experiments import random_experiments
+from .lm_dummy import lm_dummy
+from .screen_trex import screen_trex
+from .add_dummies import add_dummies, add_dummies_GVS
+from .fdp import FDP, TPP, fdp_hat
+from .select_var_fun import select_var_fun
+from .select_var_fun_DA_BT import select_var_fun_DA_BT
+from .phi_prime_fun import Phi_prime_fun
+from .gauss_data import generate_gaussian_data
+
+__version__ = '0.6.0'