vfa 0.1.0__tar.gz

vfa-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Your Name
+
+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.

vfa-0.1.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include README.md
+include LICENSE
+include pyproject.toml
+recursive-include vfa *.py

vfa-0.1.0/PKG-INFO

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: vfa
+Version: 0.1.0
+Summary: Variance Feature Analysis for binary classification feature selection
+Author-email: mohdadil <mohdadil@live.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/nqmn/vfa
+Project-URL: Repository, https://github.com/nqmn/vfa
+Project-URL: Bug Tracker, https://github.com/nqmn/vfa/issues
+Keywords: feature-selection,machine-learning,variance-analysis,classification
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Dynamic: license-file
+
+# VFA - Variance Feature Analysis
+
+A Python package for binary classification feature selection using variance-based analysis.
+
+## Overview
+
+Variance Feature Analysis (VFA) implements a feature selection method based on the Class-Variance Ratio (CVR). It selects the most discriminative features for binary classification tasks by analyzing the ratio of between-class variance to total variance.
+
+## Installation
+
+```bash
+pip install vfa
+```
+
+## Features
+
+- Fast variance-based feature selection for binary classification
+- Automatic feature ranking using Class-Variance Ratio (CVR)
+- Weighted feature aggregation
+- Compatible with scikit-learn workflows
+- Lightweight with minimal dependencies (only NumPy)
+
+## Usage
+
+```python
+from vfa import variance_feature_analysis
+import numpy as np
+
+# Example data
+X = np.random.rand(100, 20)  # 100 samples, 20 features
+y = np.random.randint(0, 2, 100)  # Binary labels
+
+# Select top 5 features
+X_selected, f_aggregated, selected_indices, scores = variance_feature_analysis(X, y, k=5)
+
+print(f"Selected feature indices: {selected_indices}")
+print(f"Feature scores: {scores[selected_indices]}")
+```
+
+## Parameters
+
+- `X` (array-like): Training data features of shape (n_samples, n_features)
+- `y` (array-like): Target labels of shape (n_samples,) - must be binary
+- `k` (int, default=8): Number of top features to select
+- `epsilon` (float, default=1e-12): Small constant to prevent division by zero
+
+## Returns
+
+- `X_selected`: Selected feature subset
+- `f_aggregated`: Weighted aggregation of selected features
+- `selected_idx`: Indices of selected features
+- `scores`: CVR scores for all features
+
+## How It Works
+
+The algorithm:
+1. Computes within-class and between-class variance for each feature
+2. Calculates the Class-Variance Ratio (CVR) = B / (B + W)
+3. Selects the top-k features with highest CVR scores
+4. Returns selected features and their weighted aggregation
+
+## Requirements
+
+- Python >=3.8
+- NumPy >=1.20.0
+
+## Development
+
+```bash
+# Clone the repository
+git clone https://github.com/nqmn/vfa.git
+cd vfa
+
+# Install development dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+```
+
+## License
+
+MIT License - see LICENSE file for details.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## Citation
+
+If you use this package in your research, please cite:
+
+```bibtex
+@software{vfa2024,
+  title={VFA: Variance Feature Analysis},
+  author={Mohd Adil Mokti},
+  year={2026},
+  url={https://github.com/nqmn/vfa}
+}
+```

vfa-0.1.0/README.md

@@ -0,0 +1,100 @@
+# VFA - Variance Feature Analysis
+
+A Python package for binary classification feature selection using variance-based analysis.
+
+## Overview
+
+Variance Feature Analysis (VFA) implements a feature selection method based on the Class-Variance Ratio (CVR). It selects the most discriminative features for binary classification tasks by analyzing the ratio of between-class variance to total variance.
+
+## Installation
+
+```bash
+pip install vfa
+```
+
+## Features
+
+- Fast variance-based feature selection for binary classification
+- Automatic feature ranking using Class-Variance Ratio (CVR)
+- Weighted feature aggregation
+- Compatible with scikit-learn workflows
+- Lightweight with minimal dependencies (only NumPy)
+
+## Usage
+
+```python
+from vfa import variance_feature_analysis
+import numpy as np
+
+# Example data
+X = np.random.rand(100, 20)  # 100 samples, 20 features
+y = np.random.randint(0, 2, 100)  # Binary labels
+
+# Select top 5 features
+X_selected, f_aggregated, selected_indices, scores = variance_feature_analysis(X, y, k=5)
+
+print(f"Selected feature indices: {selected_indices}")
+print(f"Feature scores: {scores[selected_indices]}")
+```
+
+## Parameters
+
+- `X` (array-like): Training data features of shape (n_samples, n_features)
+- `y` (array-like): Target labels of shape (n_samples,) - must be binary
+- `k` (int, default=8): Number of top features to select
+- `epsilon` (float, default=1e-12): Small constant to prevent division by zero
+
+## Returns
+
+- `X_selected`: Selected feature subset
+- `f_aggregated`: Weighted aggregation of selected features
+- `selected_idx`: Indices of selected features
+- `scores`: CVR scores for all features
+
+## How It Works
+
+The algorithm:
+1. Computes within-class and between-class variance for each feature
+2. Calculates the Class-Variance Ratio (CVR) = B / (B + W)
+3. Selects the top-k features with highest CVR scores
+4. Returns selected features and their weighted aggregation
+
+## Requirements
+
+- Python >=3.8
+- NumPy >=1.20.0
+
+## Development
+
+```bash
+# Clone the repository
+git clone https://github.com/nqmn/vfa.git
+cd vfa
+
+# Install development dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+```
+
+## License
+
+MIT License - see LICENSE file for details.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## Citation
+
+If you use this package in your research, please cite:
+
+```bibtex
+@software{vfa2024,
+  title={VFA: Variance Feature Analysis},
+  author={Mohd Adil Mokti},
+  year={2026},
+  url={https://github.com/nqmn/vfa}
+}
+```

vfa-0.1.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "vfa"
+version = "0.1.0"
+description = "Variance Feature Analysis for binary classification feature selection"
+readme = "README.md"
+authors = [
+    {name = "mohdadil", email = "mohdadil@live.com"}
+]
+license = "MIT"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+keywords = ["feature-selection", "machine-learning", "variance-analysis", "classification"]
+requires-python = ">=3.8"
+dependencies = [
+    "numpy>=1.20.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-cov>=4.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/nqmn/vfa"
+Repository = "https://github.com/nqmn/vfa"
+"Bug Tracker" = "https://github.com/nqmn/vfa/issues"
+
+[tool.setuptools]
+packages = ["vfa"]

vfa-0.1.0/setup.cfg

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

vfa-0.1.0/tests/test_vfa.py

@@ -0,0 +1,99 @@
+import numpy as np
+import pytest
+from vfa import variance_feature_analysis
+
+
+def test_basic_functionality():
+    """Test basic functionality with simple binary classification data."""
+    np.random.seed(42)
+    X = np.random.rand(100, 10)
+    y = np.random.randint(0, 2, 100)
+
+    X_selected, f_agg, indices, scores = variance_feature_analysis(X, y, k=5)
+
+    assert X_selected.shape == (100, 5), "Selected features shape mismatch"
+    assert f_agg.shape == (100,), "Aggregated features shape mismatch"
+    assert len(indices) == 5, "Number of selected indices mismatch"
+    assert len(scores) == 10, "Scores length should match original feature count"
+
+
+def test_k_exceeds_features():
+    """Test that k is capped at number of features."""
+    np.random.seed(42)
+    X = np.random.rand(50, 5)
+    y = np.random.randint(0, 2, 50)
+
+    X_selected, f_agg, indices, scores = variance_feature_analysis(X, y, k=10)
+
+    assert X_selected.shape[1] == 5, "Should cap k at number of features"
+    assert len(indices) == 5, "Indices should be capped at number of features"
+
+
+def test_feature_scores_range():
+    """Test that CVR scores are in valid range [0, 1]."""
+    np.random.seed(42)
+    X = np.random.rand(100, 10)
+    y = np.random.randint(0, 2, 100)
+
+    _, _, _, scores = variance_feature_analysis(X, y, k=5)
+
+    assert np.all(scores >= 0), "Scores should be non-negative"
+    assert np.all(scores <= 1), "Scores should not exceed 1"
+
+
+def test_discriminative_features():
+    """Test that discriminative features get higher scores."""
+    np.random.seed(42)
+
+    # Create data where first feature is highly discriminative
+    X = np.random.rand(100, 5)
+    y = np.array([0] * 50 + [1] * 50)
+
+    # Make first feature discriminative
+    X[:50, 0] = 0.0 + np.random.rand(50) * 0.1  # Class 0: low values
+    X[50:, 0] = 0.9 + np.random.rand(50) * 0.1  # Class 1: high values
+
+    _, _, indices, scores = variance_feature_analysis(X, y, k=5)
+
+    assert 0 in indices, "Discriminative feature should be selected"
+    assert scores[0] > scores[1:].mean(), "Discriminative feature should have high score"
+
+
+def test_epsilon_prevents_division_by_zero():
+    """Test that epsilon parameter prevents division by zero."""
+    np.random.seed(42)
+    X = np.zeros((100, 5))  # All zeros
+    y = np.random.randint(0, 2, 100)
+
+    # Should not raise division by zero error
+    X_selected, f_agg, indices, scores = variance_feature_analysis(X, y, k=3)
+
+    assert not np.any(np.isnan(scores)), "Should not produce NaN scores"
+    assert not np.any(np.isinf(scores)), "Should not produce infinite scores"
+
+
+def test_output_types():
+    """Test that outputs have correct types."""
+    np.random.seed(42)
+    X = np.random.rand(100, 10)
+    y = np.random.randint(0, 2, 100)
+
+    X_selected, f_agg, indices, scores = variance_feature_analysis(X, y, k=5)
+
+    assert isinstance(X_selected, np.ndarray), "X_selected should be ndarray"
+    assert isinstance(f_agg, np.ndarray), "f_agg should be ndarray"
+    assert isinstance(indices, np.ndarray), "indices should be ndarray"
+    assert isinstance(scores, np.ndarray), "scores should be ndarray"
+
+
+def test_aggregated_feature_weights():
+    """Test that aggregated features are properly weighted."""
+    np.random.seed(42)
+    X = np.random.rand(100, 10)
+    y = np.random.randint(0, 2, 100)
+
+    X_selected, f_agg, indices, scores = variance_feature_analysis(X, y, k=5)
+
+    # Aggregated feature should be in reasonable range
+    assert f_agg.min() >= 0, "Aggregated features should be non-negative (weighted from positive scores)"
+    assert not np.any(np.isnan(f_agg)), "Aggregated features should not be NaN"

vfa-0.1.0/vfa/__init__.py

@@ -0,0 +1,10 @@
+"""
+VFA (Variance Feature Analysis)
+
+A Python package for binary classification feature selection using variance-based analysis.
+"""
+
+from .vfa import variance_feature_analysis
+
+__version__ = "0.1.0"
+__all__ = ["variance_feature_analysis"]

vfa-0.1.0/vfa/vfa.py

@@ -0,0 +1,78 @@
+import numpy as np
+
+
+def variance_feature_analysis(X, y, k=8, epsilon=1e-12):
+    """
+    Perform variance-based feature selection for binary classification.
+
+    This function selects the top-k features based on the Class-Variance Ratio (CVR),
+    which measures the ratio of between-class variance to total variance for each feature.
+
+    Parameters
+    ----------
+    X : array-like of shape (n_samples, n_features)
+        Training data features.
+    y : array-like of shape (n_samples,)
+        Target labels (binary: two unique classes).
+    k : int, default=8
+        Number of top features to select. Will be capped at n_features if k > n_features.
+    epsilon : float, default=1e-12
+        Small constant to prevent division by zero.
+
+    Returns
+    -------
+    X_selected : ndarray of shape (n_samples, k)
+        Selected feature subset.
+    f_aggregated : ndarray of shape (n_samples,)
+        Weighted aggregation of selected features.
+    selected_idx : ndarray of shape (k,)
+        Indices of selected features.
+    scores : ndarray of shape (n_features,)
+        CVR scores for all features.
+
+    Examples
+    --------
+    >>> from vfa import variance_feature_analysis
+    >>> import numpy as np
+    >>> X = np.random.rand(100, 20)
+    >>> y = np.random.randint(0, 2, 100)
+    >>> X_selected, f_agg, indices, scores = variance_feature_analysis(X, y, k=5)
+    >>> print(f"Selected {len(indices)} features with indices: {indices}")
+    """
+    X = np.asarray(X, dtype=float)
+    y = np.asarray(y).astype(int)
+
+    classes = np.unique(y)
+
+    c0, c1 = classes
+    X0, X1 = X[y == c0], X[y == c1]
+
+    n0, n1 = X0.shape[0], X1.shape[0]
+    n = n0 + n1
+    p0, p1 = n0 / n, n1 / n
+
+    # Class means and variances
+    mu0, mu1 = X0.mean(axis=0), X1.mean(axis=0)
+    v0,  v1  = X0.var(axis=0),  X1.var(axis=0)
+
+    # Within-class variance
+    W = p0 * v0 + p1 * v1
+
+    # Between-class variance (binary closed form)
+    B = p0 * p1 * (mu0 - mu1) ** 2
+
+    # Class-Variance Ratio (CVR)
+    scores = B / (B + W + epsilon)
+
+    # Select top-k features
+    k = min(int(k), X.shape[1])
+    selected_idx = np.argsort(scores)[-k:]
+    X_selected = X[:, selected_idx]
+
+    # Aggregation weights
+    w_raw = scores[selected_idx].copy()
+    w = w_raw / (w_raw.sum() + epsilon)
+
+    f_aggregated = X_selected @ w
+
+    return X_selected, f_aggregated, selected_idx, scores

vfa-0.1.0/vfa.egg-info/PKG-INFO

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: vfa
+Version: 0.1.0
+Summary: Variance Feature Analysis for binary classification feature selection
+Author-email: mohdadil <mohdadil@live.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/nqmn/vfa
+Project-URL: Repository, https://github.com/nqmn/vfa
+Project-URL: Bug Tracker, https://github.com/nqmn/vfa/issues
+Keywords: feature-selection,machine-learning,variance-analysis,classification
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Dynamic: license-file
+
+# VFA - Variance Feature Analysis
+
+A Python package for binary classification feature selection using variance-based analysis.
+
+## Overview
+
+Variance Feature Analysis (VFA) implements a feature selection method based on the Class-Variance Ratio (CVR). It selects the most discriminative features for binary classification tasks by analyzing the ratio of between-class variance to total variance.
+
+## Installation
+
+```bash
+pip install vfa
+```
+
+## Features
+
+- Fast variance-based feature selection for binary classification
+- Automatic feature ranking using Class-Variance Ratio (CVR)
+- Weighted feature aggregation
+- Compatible with scikit-learn workflows
+- Lightweight with minimal dependencies (only NumPy)
+
+## Usage
+
+```python
+from vfa import variance_feature_analysis
+import numpy as np
+
+# Example data
+X = np.random.rand(100, 20)  # 100 samples, 20 features
+y = np.random.randint(0, 2, 100)  # Binary labels
+
+# Select top 5 features
+X_selected, f_aggregated, selected_indices, scores = variance_feature_analysis(X, y, k=5)
+
+print(f"Selected feature indices: {selected_indices}")
+print(f"Feature scores: {scores[selected_indices]}")
+```
+
+## Parameters
+
+- `X` (array-like): Training data features of shape (n_samples, n_features)
+- `y` (array-like): Target labels of shape (n_samples,) - must be binary
+- `k` (int, default=8): Number of top features to select
+- `epsilon` (float, default=1e-12): Small constant to prevent division by zero
+
+## Returns
+
+- `X_selected`: Selected feature subset
+- `f_aggregated`: Weighted aggregation of selected features
+- `selected_idx`: Indices of selected features
+- `scores`: CVR scores for all features
+
+## How It Works
+
+The algorithm:
+1. Computes within-class and between-class variance for each feature
+2. Calculates the Class-Variance Ratio (CVR) = B / (B + W)
+3. Selects the top-k features with highest CVR scores
+4. Returns selected features and their weighted aggregation
+
+## Requirements
+
+- Python >=3.8
+- NumPy >=1.20.0
+
+## Development
+
+```bash
+# Clone the repository
+git clone https://github.com/nqmn/vfa.git
+cd vfa
+
+# Install development dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+```
+
+## License
+
+MIT License - see LICENSE file for details.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## Citation
+
+If you use this package in your research, please cite:
+
+```bibtex
+@software{vfa2024,
+  title={VFA: Variance Feature Analysis},
+  author={Mohd Adil Mokti},
+  year={2026},
+  url={https://github.com/nqmn/vfa}
+}
+```

vfa-0.1.0/vfa.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+tests/test_vfa.py
+vfa/__init__.py
+vfa/vfa.py
+vfa.egg-info/PKG-INFO
+vfa.egg-info/SOURCES.txt
+vfa.egg-info/dependency_links.txt
+vfa.egg-info/requires.txt
+vfa.egg-info/top_level.txt

vfa-0.1.0/vfa.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

vfa-0.1.0/vfa.egg-info/requires.txt

@@ -0,0 +1,5 @@
+numpy>=1.20.0
+
+[dev]
+pytest>=7.0.0
+pytest-cov>=4.0.0

vfa-0.1.0/vfa.egg-info/top_level.txt

@@ -0,0 +1 @@
+vfa