Merge dev-kia into master, for version 0.8

.github/workflows/publish_package.yml

@@ -0,0 +1,38 @@
+name: Publish Python Package
+
+on:
+  release:
+    types: [published]
+    tags:
+      - 'v*'
+  workflow_dispatch:
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.10"  # Python version for building/uploading
+
+      - name: Install build tools
+        run: |
+          python -m pip install --upgrade pip
+          pip install build twine
+
+      # Optional: Generate version file from GitHub tag
+      # - name: Generate version file
+      #   run: echo "__version__ = '${GITHUB_REF##refs/tags/}'" > your_package/_version.py
+
+      - name: Build package
+        run: python -m build
+
+      - name: Publish to PyPI
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}
+        run: twine upload dist/*

.github/workflows/tests.yml

@@ -0,0 +1,38 @@
+name: Python Package CI
+
+on:
+  #push:
+  #  branches: [master]
+  # push:
+  #   branches: [dev-kia-pypi]
+  pull_request:
+    branches: [master]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        python-version: ["3.9", "3.10", "3.11", "3.12"]
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Upgrade pip, install build tools
+        run: |
+          python -m pip install --upgrade pip setuptools wheel build
+
+      - name: Install your package with test dependencies
+        run: |
+          pip install .[test]   # assumes you've defined [project.optional-dependencies] in pyproject.toml
+
+      - name: Run pytest
+        run: |
+          pytest --disable-warnings --maxfail=1 --tb=short

.gitignore

@@ -5,6 +5,7 @@ run_test.py
 __pycache__/
 *.py[cod]
 *$py.class
+.pytest_cache
 
 # C extensions
 *.so
@@ -61,17 +62,27 @@ docs/_build/
 # PyBuilder
 target/
 
-#Ipython Notebook
+# Others
 .ipynb_checkpoints
-
-testing.ipynb
-
 *.lprof
-
 *.prof
-/demo_scikitrebate.ipynb
-
 *.DS_Store
-.idea/
-
-analysis_pipeline/skrebatewip
+.idea/ 
+
+# Files
+demo/data
+BenchmarkData.zip
+analysis_pipeline/
+BenchmarkData/
+BenchmarkData2/
+BenchmarkData3/
+BenchmarkData4/
+skrebate_old
+analysis/BasicXOR/
+analysis/BasicXOR2/
+analysis/BasicXOR2_2/
+analysis/BasicXOR3/
+analysis/jobs/
+analysis/logs/
+analysis/core2wayEpistasis
+*.zip

README.md

@@ -12,30 +12,33 @@ Package information: ![Python 2.7](https://img.shields.io/badge/python-2.7-blue.
 [![PyPI version](https://badge.fury.io/py/skrebate.svg)](https://badge.fury.io/py/skrebate)
 
 # scikit-rebate
-This package includes a scikit-learn-compatible Python implementation of ReBATE, a suite of [Relief-based feature selection algorithms](https://en.wikipedia.org/wiki/Relief_(feature_selection)) for Machine Learning. These Relief-Based algorithms (RBAs) are designed for feature weighting/selection as part of a machine learning pipeline (supervised learning). Presently this includes the following core RBAs: ReliefF, SURF, SURF\*, MultiSURF\*, and MultiSURF. Additionally, an implementation of the iterative TuRF mechanism and VLSRelief is included. **It is still under active development** and we encourage you to check back on this repository regularly for updates.
 
-These algorithms offer a computationally efficient way to perform feature selection that is sensitive to feature interactions as well as simple univariate associations, unlike most currently available filter-based feature selection methods. The main benefit of Relief algorithms is that they identify feature interactions without having to exhaustively check every pairwise interaction, thus taking significantly less time than exhaustive pairwise search.
+This package includes a scikit-learn-compatible Python implementation of ReBATE, a suite of [Relief-based feature selection algorithms](<https://en.wikipedia.org/wiki/Relief_(feature_selection)>) for Machine Learning. These Relief-based algorithms (RBAs) are designed for feature weighting/selection as part of a machine learning pipeline (supervised learning). Presently this includes the following core RBAs: ReliefF, SURF, SURF\*, MultiSURF\*, MultiSURF, SWRF\*, SWRF, MultiSWRF\*, MultiSWRF, MultiSWRFDB\*, MultiSWRFDB, and μ-Relief. Additionally, an implementation of the iterative TuRF mechanism and VLSRelief is included. **It is still under active development** and we encourage you to check back on this repository regularly for updates.
 
-Certain algorithms require user specified run parameters (e.g. ReliefF requires the user to specify some 'k' number of nearest neighbors). 
+These algorithms offer a computationally efficient way to perform feature selection that is sensitive to feature interactions as well as simple univariate associations, unlike most currently available filter-based feature selection methods. The main benefit of Relief-based algorithms is that they identify feature interactions without having to exhaustively check every pairwise interaction, thus taking significantly less time than exhaustive pairwise search.
 
-Relief algorithms are commonly applied to genetic analyses, where epistasis (i.e., feature interactions) is common. However, the algorithms implemented in this package can be applied to almost any supervised classification data set and supports:
+<!-- Certain algorithms require user specified run parameters (e.g. ReliefF requires the user to specify some 'k' number of nearest neighbors).  -->
 
-* Feature sets that are discrete/categorical, continuous-valued or a mix of both
+Certain algorithms have run parameters that the user can specify, or if not specified, default to preset values (e.g. ReliefF’s parameter for ‘k’ number of nearest neighbors).
 
-* Data with missing values
+Relief-based algorithms are commonly applied to genetic analyses, where epistasis (i.e., feature interactions) is common. However, the algorithms implemented in this package can be applied to almost any supervised, structured data set and support:
 
-* Binary endpoints (i.e., classification)
+- Feature sets that are discrete/categorical, continuous-valued or a mix of both
 
-* Multi-class endpoints (i.e., classification)
+- Data with missing values
 
-* Continuous endpoints (i.e., regression)
+- Binary endpoints (i.e., classification)
 
-Built into this code, is a strategy to 'automatically' detect from the loaded data, these relevant characteristics.
+- Multi-class endpoints (i.e., classification)
 
-Of our two initial ReBATE software releases, this scikit-learn compatible version primarily focuses on ease of incorporation into a scikit learn analysis pipeline. 
+- Continuous endpoints (i.e., regression)
+
+Built into this code is a strategy to 'automatically' detect these relevant characteristics from the loaded data.
+
+Of our two initial ReBATE software releases, this scikit-learn compatible version primarily focuses on ease of incorporation into a scikit-learn analysis pipeline.
 This code is most appropriate for scikit-learn users, Windows operating system users, beginners, or those looking for the most recent ReBATE developments.
 
-An alternative 'stand-alone' version of [ReBATE](https://github.com/EpistasisLab/ReBATE) is also available that focuses on improving run-time with the use of Cython for optimization. This implementation also outputs feature names and associated feature scores as a text file by default. 
+An alternative 'stand-alone' version of [ReBATE](https://github.com/EpistasisLab/ReBATE) is also available that focuses on improving run-time with the use of Cython for optimization. This implementation also outputs feature names and associated feature scores as a text file by default.
 
 ## License
 
@@ -47,11 +50,11 @@ Generally, we have licensed scikit-rebate to make it as widely usable as possibl
 
 scikit-rebate is built on top of the following existing Python packages:
 
-* NumPy
+- NumPy
 
-* SciPy
+- SciPy
 
-* scikit-learn
+- scikit-learn
 
 All of the necessary Python packages can be installed via the [Anaconda Python distribution](https://www.continuum.io/downloads), which we strongly recommend that you use. We also strongly recommend that you use Python 3 over Python 2 if you're given the choice.
 
@@ -71,30 +74,97 @@ Please [file a new issue](https://github.com/EpistasisLab/scikit-rebate/issues/n
 
 ## Usage
 
-We have designed the Relief algorithms to be integrated directly into scikit-learn machine learning workflows. For example, the ReliefF algorithm can be used as a feature selection step in a scikit-learn pipeline as follows.
+### Basic Usage
+
+To use an algorithm from ReBATE as a feature selection method:
 
-```python
+```Python
+# Import necessary packages
+import pandas as pd
+from skrebate import ReliefF
+
+# Load the example dataset
+genetic_data = pd.read_csv(
+    './data/GAMETES_Epistasis_2-Way_20atts_0.4H_EDM-1_1.csv')
+
+# Separate the features and labels from the dataset
+features, labels = genetic_data.drop('class', axis=1).values, genetic_data['class'].values
+
+# Apply the ReliefF algorithm for feature selection
+fs = ReliefF()
+fs.fit(features, labels)
+
+# Print out the results
+feature_name = genetic_data.drop('class', axis=1).columns
+fs.summary(feature_name=feature_name)
+
+>>> Feature name   Feature importances    Feature rank
+>>> P2             0.12330000             1
+>>> P1             0.11892500             2
+>>> N0             -0.00018125            3
+>>> N10            -0.00075625            4
+>>> N13            -0.00320625            5
+>>> N14            -0.00402500            6
+>>> N4             -0.00582500            7
+>>> N1             -0.00595000            8
+>>> N8             -0.00653750            9
+>>> N12            -0.00696250            10
+>>> N16            -0.00705000            11
+>>> N17            -0.00740625            12
+>>> N5             -0.00788750            13
+>>> N11            -0.00822500            14
+>>> N9             -0.00826250            15
+>>> N2             -0.00871875            16
+>>> N3             -0.00872500            17
+>>> N7             -0.00991875            18
+>>> N6             -0.01038750            19
+>>> N15            -0.01044375            20
+```
+
+### Using as End-to-end Pipeline
+
+We have designed the Relief-based algorithms to be integrated directly into scikit-learn machine learning workflows. For example, the ReliefF algorithm can be used as a feature selection step in a scikit-learn pipeline as follows:
+
+```Python
+# Import necessary packages
 import pandas as pd
-import numpy as np
 from sklearn.pipeline import make_pipeline
 from skrebate import ReliefF
 from sklearn.ensemble import RandomForestClassifier
-from sklearn.model_selection import cross_val_score
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score
 
-genetic_data = pd.read_csv('https://github.com/EpistasisLab/scikit-rebate/raw/master/data/'
-                           'GAMETES_Epistasis_2-Way_20atts_0.4H_EDM-1_1.tsv.gz',
-                           sep='\t', compression='gzip')
+# Load the example dataset
+genetic_data = pd.read_csv(
+    './data/GAMETES_Epistasis_2-Way_20atts_0.4H_EDM-1_1.csv')
 
+# Separate the features and labels from the dataset
 features, labels = genetic_data.drop('class', axis=1).values, genetic_data['class'].values
 
-clf = make_pipeline(ReliefF(n_features_to_select=2, n_neighbors=100),
-                    RandomForestClassifier(n_estimators=100))
+# Split the data to training and testing
+X_train, X_test, y_train, y_test = train_test_split(features, labels, test_size=0.3, random_state=42)
 
-print(np.mean(cross_val_score(clf, features, labels)))
->>> 0.795
+# Make pipeline
+clf = make_pipeline(
+    ReliefF(n_features_to_select=2),
+    RandomForestClassifier(n_estimators=100)
+)
+
+# Train the model
+clf.fit(X_train, y_train)
+
+# Evaluate the model on testing set
+y_pred = clf.predict(X_test)
+accuracy = accuracy_score(y_test, y_pred)
+print(f"Accuracy: {accuracy:.3f}")
+>>> Accuracy: 0.781
 ```
 
-For more information on the Relief algorithms available in this package and how to use them, please refer to our [usage documentation](https://EpistasisLab.github.io/scikit-rebate/using/).
+<!-- For more information on the Relief-based algorithms available in this package and how to use them, please refer to our [usage documentation](https://EpistasisLab.github.io/scikit-rebate/using/).
+
+For updated documentation in this forked repository, please refer to this [updated usage documentation](https://urbslab.github.io/scikit-rebate/using/) -->
+
+For more information on the Relief-based algorithms available in this package and how to use them, please refer to our [usage documentation](https://urbslab.github.io/scikit-rebate/using/).
 
 ## Contributing to scikit-rebate
 
@@ -106,15 +176,19 @@ Please refer to our [contribution guidelines](https://EpistasisLab.github.io/sci
 
 If you use scikit-rebate in a scientific publication, please consider citing the following paper:
 
-Ryan J. Urbanowicz, Randal S. Olson, Peter Schmitt, Melissa Meeker, Jason H. Moore (2017). [Benchmarking Relief-Based Feature Selection Methods](https://arxiv.org/abs/1711.08477). *arXiv preprint*, under review.
+Ryan J. Urbanowicz, Randal S. Olson, Peter Schmitt, Melissa Meeker, Jason H. Moore (2018). Benchmarking Relief-Based Feature Selection Methods for Bioinformatics Data Mining. _Journal of Biomedical Informatics_, 85, 168-188. DOI: [10.1016/j.jbi.2018.07.015](https://doi.org/10.1016/j.jbi.2018.07.015)
 
-BibTeX entry:
+### BibTeX entry:
 
 ```bibtex
-@misc{Urbanowicz2017Benchmarking,
-    author = {Urbanowicz, Ryan J. and Olson, Randal S. and Schmitt, Peter and Meeker, Melissa and Moore, Jason H.},
-    title = {Benchmarking Relief-Based Feature Selection Methods},
-    year = {2017},
-    howpublished = {arXiv e-print. https://arxiv.org/abs/1711.08477},
+@article{Urbanowicz2018Benchmarking,
+  author    = {Urbanowicz, Ryan J. and Olson, Randal S. and Schmitt, Peter and Meeker, Melissa and Moore, Jason H.},
+  title     = {Benchmarking Relief-Based Feature Selection Methods for Bioinformatics Data Mining},
+  journal   = {Journal of Biomedical Informatics},
+  volume    = {85},
+  pages     = {168--188},
+  year      = {2018},
+  doi       = {10.1016/j.jbi.2018.07.015},
+  url       = {https://doi.org/10.1016/j.jbi.2018.07.015}
 }
 ```

analysis/check_run_validity.py

@@ -0,0 +1,30 @@
+import os
+
+def find_error_runs(log_dir, error_keywords=None):
+    if error_keywords is None:
+        # Add more as needed
+        error_keywords = ["error", "failed", "segmentation fault", "traceback", "exception", "abort", "core dumped"]
+
+    error_runs = []
+
+    for root, _, files in os.walk(log_dir):
+        for file in files:
+            if file.endswith((".err", ".log", ".out")):
+                filepath = os.path.join(root, file)
+                try:
+                    with open(filepath, "r", encoding="utf-8", errors="ignore") as f:
+                        content = f.read().lower()
+                        if any(keyword in content for keyword in error_keywords):
+                            error_runs.append(filepath)
+                except Exception as e:
+                    print(f"Error reading {filepath}: {e}")
+
+    return error_runs
+
+# Example usage:
+log_directory = "./logs"  # Change this to your logs directory
+errors = find_error_runs(log_directory)
+
+print("Jobs with errors:")
+for err_file in errors:
+    print(err_file)