trexselector 0.5.9__tar.gz

trexselector-0.5.9/PKG-INFO

@@ -0,0 +1,166 @@
+Metadata-Version: 2.2
+Name: trexselector
+Version: 0.5.9
+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.5.9
+```
+
+## 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}")
+```
+
+## Library Reference
+
+### Main Functions
+
+#### trex(X, y, tFDR=0.2, K=20, max_num_dummies=10, max_T_stop=True, method="trex", ...)
+
+The main function for high-dimensional variable selection with FDR control.
+
+- **X**: ndarray - Predictor matrix of shape (n, p).
+- **y**: ndarray - Response vector of shape (n,).
+- **tFDR**: float - Target FDR level (between 0 and 1).
+- **K**: int - Number of random experiments.
+- **max_num_dummies**: int - Factor determining maximum number of dummies.
+- **max_T_stop**: bool - If True, maximum number of included dummies is set to ceiling(n/2).
+- **method**: str - Method to use ('trex', 'trex+GVS', 'trex+DA+AR1', 'trex+DA+equi', 'trex+DA+BT', 'trex+DA+NN').
+- **Returns**: dict - Contains selected variables and additional information.
+
+#### screen_trex(X, y, tFDR=0.2, K=20, max_num_dummies=10, ...)
+
+Screening variant of T-Rex for ultra-high dimensional datasets.
+
+- **X**, **y**, **tFDR**, **K**: Same as trex().
+- **q**: int - Number of variables to select in each split.
+- **num_splits**: int - Number of splits of the original problem.
+- **Returns**: dict - Contains selected variables and screening information.
+
+#### random_experiments(X, y, K=20, T_stop=1, num_dummies=None, ...)
+
+Run K random experiments with the T-Rex selector.
+
+- **X**, **y**, **K**: Same as trex().
+- **T_stop**: int - Number of included dummies before stopping.
+- **num_dummies**: int - Number of dummies to append.
+- **parallel_process**: bool - If True, experiments run in parallel.
+- **Returns**: dict - Contains experiment results and statistics.
+
+### Helper Functions
+
+#### add_dummies(X, num_dummies)
+
+Add random dummy variables to the predictor matrix.
+
+- **X**: ndarray - Predictor matrix.
+- **num_dummies**: int - Number of dummies to append.
+- **Returns**: ndarray - Matrix with appended dummies.
+
+#### add_dummies_GVS(X, num_dummies, corr_max=0.5)
+
+Add dummy variables with correlation constraints for group variable selection.
+
+- **X**: ndarray - Predictor matrix.
+- **num_dummies**: int - Number of dummies to append.
+- **corr_max**: float - Maximum allowed correlation between predictors.
+- **Returns**: dict - Contains matrix with dummies and group information.
+
+#### FDP(beta_hat, beta)
+
+Compute the false discovery proportion.
+
+- **beta_hat**: ndarray - Estimated coefficient vector.
+- **beta**: ndarray - True coefficient vector.
+- **Returns**: float - False discovery proportion.
+
+#### TPP(beta_hat, beta)
+
+Compute the true positive proportion.
+
+- **beta_hat**: ndarray - Estimated coefficient vector.
+- **beta**: ndarray - True coefficient vector.
+- **Returns**: float - True positive proportion.
+
+#### generate_gaussian_data(n=50, p=100, seed=789)
+
+Generate synthetic Gaussian data for testing.
+
+- **n**: int - Number of observations.
+- **p**: int - Number of variables.
+- **seed**: int - Random seed.
+- **Returns**: tuple - (X, y, beta) containing predictor matrix, response, and true coefficients.
+
+### Advanced Features
+
+The package supports several variants of the T-Rex selector:
+
+- **Basic T-Rex**: Standard variable selection with FDR control
+- **T-Rex+GVS**: Group variable selection using correlation structure
+- **T-Rex+DA variants**: Dependency-aware variants
+  - AR1: Using AR(1) correlation structure
+  - Equi: Using equicorrelation structure
+  - BT: Using binary tree structure
+  - NN: Using nearest neighbor structure
+
+## 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.5.9/README.md

@@ -0,0 +1,137 @@
+# 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.5.9
+```
+
+## 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}")
+```
+
+## Library Reference
+
+### Main Functions
+
+#### trex(X, y, tFDR=0.2, K=20, max_num_dummies=10, max_T_stop=True, method="trex", ...)
+
+The main function for high-dimensional variable selection with FDR control.
+
+- **X**: ndarray - Predictor matrix of shape (n, p).
+- **y**: ndarray - Response vector of shape (n,).
+- **tFDR**: float - Target FDR level (between 0 and 1).
+- **K**: int - Number of random experiments.
+- **max_num_dummies**: int - Factor determining maximum number of dummies.
+- **max_T_stop**: bool - If True, maximum number of included dummies is set to ceiling(n/2).
+- **method**: str - Method to use ('trex', 'trex+GVS', 'trex+DA+AR1', 'trex+DA+equi', 'trex+DA+BT', 'trex+DA+NN').
+- **Returns**: dict - Contains selected variables and additional information.
+
+#### screen_trex(X, y, tFDR=0.2, K=20, max_num_dummies=10, ...)
+
+Screening variant of T-Rex for ultra-high dimensional datasets.
+
+- **X**, **y**, **tFDR**, **K**: Same as trex().
+- **q**: int - Number of variables to select in each split.
+- **num_splits**: int - Number of splits of the original problem.
+- **Returns**: dict - Contains selected variables and screening information.
+
+#### random_experiments(X, y, K=20, T_stop=1, num_dummies=None, ...)
+
+Run K random experiments with the T-Rex selector.
+
+- **X**, **y**, **K**: Same as trex().
+- **T_stop**: int - Number of included dummies before stopping.
+- **num_dummies**: int - Number of dummies to append.
+- **parallel_process**: bool - If True, experiments run in parallel.
+- **Returns**: dict - Contains experiment results and statistics.
+
+### Helper Functions
+
+#### add_dummies(X, num_dummies)
+
+Add random dummy variables to the predictor matrix.
+
+- **X**: ndarray - Predictor matrix.
+- **num_dummies**: int - Number of dummies to append.
+- **Returns**: ndarray - Matrix with appended dummies.
+
+#### add_dummies_GVS(X, num_dummies, corr_max=0.5)
+
+Add dummy variables with correlation constraints for group variable selection.
+
+- **X**: ndarray - Predictor matrix.
+- **num_dummies**: int - Number of dummies to append.
+- **corr_max**: float - Maximum allowed correlation between predictors.
+- **Returns**: dict - Contains matrix with dummies and group information.
+
+#### FDP(beta_hat, beta)
+
+Compute the false discovery proportion.
+
+- **beta_hat**: ndarray - Estimated coefficient vector.
+- **beta**: ndarray - True coefficient vector.
+- **Returns**: float - False discovery proportion.
+
+#### TPP(beta_hat, beta)
+
+Compute the true positive proportion.
+
+- **beta_hat**: ndarray - Estimated coefficient vector.
+- **beta**: ndarray - True coefficient vector.
+- **Returns**: float - True positive proportion.
+
+#### generate_gaussian_data(n=50, p=100, seed=789)
+
+Generate synthetic Gaussian data for testing.
+
+- **n**: int - Number of observations.
+- **p**: int - Number of variables.
+- **seed**: int - Random seed.
+- **Returns**: tuple - (X, y, beta) containing predictor matrix, response, and true coefficients.
+
+### Advanced Features
+
+The package supports several variants of the T-Rex selector:
+
+- **Basic T-Rex**: Standard variable selection with FDR control
+- **T-Rex+GVS**: Group variable selection using correlation structure
+- **T-Rex+DA variants**: Dependency-aware variants
+  - AR1: Using AR(1) correlation structure
+  - Equi: Using equicorrelation structure
+  - BT: Using binary tree structure
+  - NN: Using nearest neighbor structure
+
+## 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.5.9/setup.cfg

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

trexselector-0.5.9/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.5.9",
+    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.5.9/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.5.9/tests/test_trexselector/__init__.py

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

trexselector-0.5.9/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.5.9/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.5.9/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]"