refs-mcc 1.0.0__tar.gz

refs_mcc-1.0.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include requirements.txt
+recursive-include src *.py

refs_mcc-1.0.0/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: refs-mcc
+Version: 1.0.0
+Summary: Recursive Ensemble Feature Selection using Matthews Correlation Coefficient
+Author: Alejandro Lopez-Rincon, Alberto Tonda, Brigitta Varga
+Author-email: Alejandro Lopez-Rincon <alejandrolopezrn@gmail.com>
+License: MIT
+Project-URL: source, https://github.com/steppenwolf0/REFS-MCC/
+Project-URL: tracker, https://github.com/steppenwolf0/REFS-MCC/issues
+Keywords: feature-selection,matthews-correlation-coefficient,bioinformatics,machine-learning,ensemble-learning
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: joblib>=1.5.3
+Requires-Dist: matplotlib>=3.10.8
+Requires-Dist: numpy>=2.4.1
+Requires-Dist: pandas>=2.3.3
+Requires-Dist: scikit-learn>=1.8.0
+Requires-Dist: scipy>=1.17.0
+Requires-Dist: statsmodels>=0.14.6
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+
+# REFS-MCC
+Recursive Ensemble Feauture Selection using Matthews Correlation Coefficient
+
+--------------------------------------------------------------------
+Installation
+
+```bash
+   pip install refs-mcc
+```
+
+After installation it can be used as the following (using the default parameters):
+```python
+    from refs_mcc import REFS_MCC
+    REFS_MCC().run()
+```
+
+Or from CLI. For more information, run:
+```bash
+   refs-mcc --help
+```
+ 
+--------------------------------------------------------------------
+Input
+
+Next to the folder where the code is executed from, a `data` folder needs to be present with the following files:
+- `data_0.csv`
+- `features_0.csv`
+- `ids.csv`
+- `labels.csv`
+
+--------------------------------------------------------------------
+Output
+
+The following folders and files will be created:
+- run folders (`run0`, `run1`, ..., `run{n-1}`, where n is the selected number of total runs, 10 by default)
+- `best` folder 
+- `sumFig.pdf` & `sumFig.png`
+
+--------------------------------------------------------------------

refs_mcc-1.0.0/README.md

@@ -0,0 +1,25 @@
+# REFS-MCC
+Recursive Ensemble Feauture Selection using Matthews Correlation Coefficient
+
+--------------------------------------------------------------------
+Instructions
+
+- From the src folder run the refs-mcc (the default parameters are: 10 threads, 10 folds and 10 total runs):
+```bash
+   python refs_mcc.py
+```
+
+- For the full list of command line args:
+```bash
+   python refs_mcc.py --help
+```
+
+--------------------------------------------------------------------
+Output
+
+The following folders and files will be created:
+- run folders (`run0`, `run1`, ..., `run{n-1}`, where n is the selected number of total runs, 10 by default)
+- `best` folder 
+- `sumFig.pdf` & `sumFig.png`
+
+--------------------------------------------------------------------

refs_mcc-1.0.0/README_PYPI.md

@@ -0,0 +1,39 @@
+# REFS-MCC
+Recursive Ensemble Feauture Selection using Matthews Correlation Coefficient
+
+--------------------------------------------------------------------
+Installation
+
+```bash
+   pip install refs-mcc
+```
+
+After installation it can be used as the following (using the default parameters):
+```python
+    from refs_mcc import REFS_MCC
+    REFS_MCC().run()
+```
+
+Or from CLI. For more information, run:
+```bash
+   refs-mcc --help
+```
+ 
+--------------------------------------------------------------------
+Input
+
+Next to the folder where the code is executed from, a `data` folder needs to be present with the following files:
+- `data_0.csv`
+- `features_0.csv`
+- `ids.csv`
+- `labels.csv`
+
+--------------------------------------------------------------------
+Output
+
+The following folders and files will be created:
+- run folders (`run0`, `run1`, ..., `run{n-1}`, where n is the selected number of total runs, 10 by default)
+- `best` folder 
+- `sumFig.pdf` & `sumFig.png`
+
+--------------------------------------------------------------------

refs_mcc-1.0.0/pyproject.toml

@@ -0,0 +1,74 @@
+[project]
+name = "refs-mcc"
+version = "1.0.0"
+description = "Recursive Ensemble Feature Selection using Matthews Correlation Coefficient"
+keywords = ["feature-selection", "matthews-correlation-coefficient", "bioinformatics", "machine-learning", "ensemble-learning"]
+readme = "README_PYPI.md"
+requires-python = ">=3.10"
+authors = [
+    { name = "Alejandro Lopez-Rincon", email = "alejandrolopezrn@gmail.com" }, 
+    { name = "Alejandro Lopez-Rincon" }, 
+    { name = "Alberto Tonda" },
+    { name = "Brigitta Varga" }
+]
+license = { text = "MIT" }
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Science/Research",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: Implementation :: CPython",
+  "Topic :: Scientific/Engineering :: Bio-Informatics",
+]
+
+dependencies = [
+    "joblib>=1.5.3",
+    "matplotlib>=3.10.8",
+    "numpy>=2.4.1",
+    "pandas>=2.3.3",
+    "scikit-learn>=1.8.0",
+    "scipy>=1.17.0",
+    "statsmodels>=0.14.6",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+]
+
+[project.scripts]
+refs-mcc = "refs_mcc:main"
+
+[project.urls]
+source = "https://github.com/steppenwolf0/REFS-MCC/"
+tracker = "https://github.com/steppenwolf0/REFS-MCC/issues"
+
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.black]
+line-length = 88
+target-version = ["py38"]
+exclude = "\\.venv|\\.git|\\.tox|build|dist"
+
+[tool.isort]
+profile = "black"
+
+[tool.pytest.ini_options]
+minversion = "6.0"
+addopts = "-q"
+testpaths = ["tests"]
+
+[tool.flake8]
+max-line-length = 88
+extend-ignore = ["E203"]
+
+[tool.check-manifest]
+ignore = ["data/*", "old/*"]

refs_mcc-1.0.0/requirements.txt

@@ -0,0 +1,67 @@
+aiohappyeyeballs==2.6.2
+aiohttp==3.14.1
+aiosignal==1.4.0
+alembic==1.18.1
+attrs==26.1.0
+Boruta==0.4.3
+catboost==1.2.10
+certifi==2026.2.25
+charset-normalizer==3.4.5
+cloudpickle==3.1.2
+cma==4.4.1
+colorama==0.4.6
+colorlog==6.10.1
+contourpy==1.3.3
+cycler==0.12.1
+filelock==3.29.4
+fonttools==4.61.1
+frozenlist==1.8.0
+fsspec==2026.6.0
+graphviz==0.21
+greenlet==3.3.1
+idna==3.11
+Jinja2==3.1.6
+joblib==1.5.3
+kiwisolver==1.4.9
+llvmlite==0.47.0
+lxml==6.0.2
+Mako==1.3.10
+MarkupSafe==3.0.3
+matplotlib==3.10.8
+mpmath==1.3.0
+multidict==6.7.1
+narwhals==2.19.0
+networkx==3.6.1
+numba==0.65.1
+numpy==2.4.1
+optuna==4.7.0
+packaging==25.0
+pandas==2.3.3
+patsy==1.0.2
+pillow==12.1.0
+plotly==6.7.0
+propcache==0.5.2
+psutil==7.2.2
+pyparsing==3.3.2
+python-dateutil==2.9.0.post0
+pytz==2025.2
+PyYAML==6.0.3
+requests==2.32.5
+scikit-learn==1.8.0
+scipy==1.17.0
+seaborn==0.13.2
+setuptools==81.0.0
+shap==0.52.0
+six==1.17.0
+slicer==0.0.8
+SQLAlchemy==2.0.46
+statsmodels==0.14.6
+sympy==1.14.0
+threadpoolctl==3.6.0
+tqdm==4.67.1
+typing_extensions==4.15.0
+tzdata==2025.3
+urllib3==2.6.3
+xgboost==3.2.0
+xxhash==3.8.0
+yarl==1.24.2

refs_mcc-1.0.0/setup.cfg

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

refs_mcc-1.0.0/src/aBioInf100.py

@@ -0,0 +1,58 @@
+from features import *
+from reduceData import *
+
+from joblib import Parallel, delayed
+import multiprocessing
+import time
+import argparse
+
+def mainRun(indexRun, numberOfFolds) :
+	run=indexRun
+	start_time = time.time()
+	globalAnt=0.0
+	globalIndex=0
+	globalAccuracy=0.0
+
+	X, y, biomarkerNames = loadDatasetOriginal(run)
+	
+	if (int(len(X[0]))>1000):
+		numberOfTopFeatures = 1000
+	else :
+		numberOfTopFeatures = int(len(X[0])*0.80)
+
+	variableSize=numberOfTopFeatures;
+	while True:
+		globalAnt=globalAccuracy
+		globalAccuracy=featureSelection(globalIndex,variableSize, run,numberOfFolds)
+		print(globalAccuracy)
+		print(globalIndex)
+		print(variableSize)
+		size,sizereduced=reduceDataset(globalIndex, run)
+		
+		if(variableSize==0):
+			break
+		variableSize=int(variableSize*0.80)
+		
+		globalIndex=globalIndex + 1
+
+	elapsed_time = time.time() - start_time
+	print("time")
+	print(elapsed_time)
+	return
+
+def main(threads, totalRuns, numberOfFolds) :
+	Parallel(n_jobs=threads, verbose=5, backend="multiprocessing")(delayed(mainRun)(i, numberOfFolds) for i in range(0,totalRuns))
+	return
+
+if __name__ == "__main__" :
+	parser = argparse.ArgumentParser(description="Run REFS-MCC - part 1")
+	parser.add_argument('--threads', type=int, default=10, help='Number of threads (default: 10)')
+	parser.add_argument('--totalRuns', type=int, default=10, help='Total number of runs (default: 10)')
+	parser.add_argument('--folds', type=int, default=10, help='Number of folds (default: 10)')
+	args = parser.parse_args()
+
+	threads=args.threads
+	totalRuns=args.totalRuns
+	numberOfFolds=args.folds
+
+	sys.exit( main(threads, totalRuns, numberOfFolds) )

refs_mcc-1.0.0/src/classifiersMulti.py

@@ -0,0 +1,227 @@
+import copy
+import datetime
+import logging
+import numpy as np
+import os
+import sys
+import pandas as pd 
+import argparse
+
+from sklearn.ensemble import AdaBoostClassifier
+from sklearn.ensemble import BaggingClassifier
+from sklearn.ensemble import ExtraTreesClassifier
+from sklearn.ensemble import GradientBoostingClassifier
+from sklearn.ensemble import RandomForestClassifier
+
+from sklearn.linear_model import ElasticNet
+from sklearn.linear_model import ElasticNetCV
+from sklearn.linear_model import Lasso
+from sklearn.linear_model import LassoCV
+from sklearn.linear_model import LogisticRegression
+from sklearn.linear_model import LogisticRegressionCV
+from sklearn.linear_model import PassiveAggressiveClassifier
+from sklearn.linear_model import RidgeClassifier
+from sklearn.linear_model import RidgeClassifierCV
+from sklearn.linear_model import SGDClassifier
+
+from sklearn.multiclass import OneVsOneClassifier 
+from sklearn.multiclass import OneVsRestClassifier
+from sklearn.multiclass import OutputCodeClassifier
+
+from sklearn.naive_bayes import BernoulliNB
+from sklearn.naive_bayes import GaussianNB
+from sklearn.naive_bayes import MultinomialNB 
+
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.neighbors import NearestCentroid
+from sklearn.neighbors import RadiusNeighborsClassifier
+
+from sklearn.svm import SVC
+
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.tree import ExtraTreeClassifier
+from sklearn.neural_network import MLPClassifier
+
+# used for normalization
+from sklearn.preprocessing import  Normalizer
+from sklearn.preprocessing import StandardScaler
+from sklearn.preprocessing import MinMaxScaler
+# used for cross-validation
+from sklearn.model_selection import StratifiedKFold
+from sklearn.metrics import roc_curve, auc
+from numpy import interp
+import matplotlib.pyplot as plt
+from pandas import read_csv
+
+from statsmodels.multivariate.manova import MANOVA
+import statsmodels.api as sm
+from scipy import stats
+from sklearn.metrics import f1_score
+def loadDataset() :
+	
+	# data used for the predictions
+	dfData = read_csv("./best/data_0.csv", header=None, sep=',')
+	dfLabels = read_csv("./best/labels.csv", header=None)
+		
+	return dfData.values, dfLabels.values.ravel() # to have it in the format that the classifiers like
+
+
+def runFeatureReduce(numberOfFolds) :
+	
+	# list of classifiers, selected on the basis of our previous paper "
+	classifierList = [
+		
+			[GradientBoostingClassifier(n_estimators=300), "GradientBoostingClassifier(n_estimators=300)"],
+			[RandomForestClassifier(n_estimators=300), "RandomForestClassifier(n_estimators=300)"],
+			[LogisticRegression(solver='lbfgs',), "LogisticRegression"],
+			[PassiveAggressiveClassifier(),"PassiveAggressiveClassifier"],
+			[SGDClassifier(), "SGDClassifier"],
+			[SVC(kernel='linear'), "SVC(linear)"],
+			[RidgeClassifier(), "RidgeClassifier"],
+			[BaggingClassifier(n_estimators=300), "BaggingClassifier(n_estimators=300)"],
+			# ensemble
+			#[AdaBoostClassifier(), "AdaBoostClassifier"],
+			#[AdaBoostClassifier(n_estimators=300), "AdaBoostClassifier(n_estimators=300)"],
+			#[AdaBoostClassifier(n_estimators=1500), "AdaBoostClassifier(n_estimators=1500)"],
+			#[BaggingClassifier(), "BaggingClassifier"],
+			
+			#[ExtraTreesClassifier(), "ExtraTreesClassifier"],
+			#[ExtraTreesClassifier(n_estimators=300), "ExtraTreesClassifier(n_estimators=300)"],
+			 # features_importances_
+			#[GradientBoostingClassifier(n_estimators=300), "GradientBoostingClassifier(n_estimators=300)"],
+			#[GradientBoostingClassifier(n_estimators=1000), "GradientBoostingClassifier(n_estimators=1000)"],
+			
+			#[RandomForestClassifier(n_estimators=300), "RandomForestClassifier(n_estimators=300)"],
+			#[RandomForestClassifier(n_estimators=1000), "RandomForestClassifier(n_estimators=1000)"], # features_importances_
+
+			# linear
+			#[ElasticNet(), "ElasticNet"],
+			#[ElasticNetCV(), "ElasticNetCV"],
+			#[Lasso(), "Lasso"],
+			#[LassoCV(), "LassoCV"],
+			 # coef_
+			#[LogisticRegressionCV(), "LogisticRegressionCV"],
+			  # coef_
+			 # coef_
+			#[RidgeClassifierCV(), "RidgeClassifierCV"],
+			 # coef_
+			 # coef_, but only if the kernel is linear...the default is 'rbf', which is NOT linear
+			
+			# naive Bayes
+			#[BernoulliNB(), "BernoulliNB"],
+			#[GaussianNB(), "GaussianNB"],
+			#[MultinomialNB(), "MultinomialNB"],
+			
+			# neighbors
+			#[KNeighborsClassifier(), "KNeighborsClassifier"], # no way to return feature importance
+			# TODO this one creates issues
+			#[NearestCentroid(), "NearestCentroid"], # it does not have some necessary methods, apparently
+			#[RadiusNeighborsClassifier(), "RadiusNeighborsClassifier"],
+			
+			# tree
+			#[DecisionTreeClassifier(), "DecisionTreeClassifier"],
+			#[ExtraTreeClassifier(), "ExtraTreeClassifier"],
+			[AdaBoostClassifier(n_estimators=300), "AdaBoostClassifier(n_estimators=300)"],
+            [ExtraTreesClassifier(n_estimators=300), "ExtraTreesClassifier(n_estimators=300)"],
+            [KNeighborsClassifier(), "KNeighborsClassifier"],
+            #[LassoCV(), "LassoCV"],
+			[MLPClassifier(), "MLPClassifier"],
+			[LassoCV(), "LassoCV"]
+			]
+	
+	# this is just a hack to check a few things
+	#classifierList = [
+	#		[RandomForestClassifier(), "RandomForestClassifier"]
+	#		]
+
+	print("Loading dataset...")
+	X, y = loadDataset()
+	
+	print(len(X))
+	print(len(X[0]))
+	print(len(y))
+
+	
+	labels=np.max(y)+1
+	# prepare folds
+	skf = StratifiedKFold(n_splits=numberOfFolds, shuffle=True)
+	indexes = [ (training, test) for training, test in skf.split(X, y) ]
+	
+	# this will be used for the top features
+	topFeatures = dict()
+	
+	# iterate over all classifiers
+	classifierIndex = 0
+	
+	
+	
+	
+	for originalClassifier, classifierName in classifierList :
+		
+		print("\nClassifier " + classifierName)
+		classifierPerformance = []
+		F1score= []
+
+		cMatrix=np.zeros((labels, labels))
+		# iterate over all folds
+		
+		indexFold = 0
+
+		yTest=[]
+		yNew=[]
+
+		for train_index, test_index in indexes :
+			
+			X_train, X_test = X[train_index], X[test_index]
+			y_train, y_test = y[train_index], y[test_index]
+			
+			# let's normalize, anyway
+			# MinMaxScaler StandardScaler Normalizer
+			scaler = StandardScaler()
+			X_train = scaler.fit_transform(X_train)
+			X_test = scaler.transform(X_test)
+
+		
+			
+			classifier = copy.deepcopy(originalClassifier)
+			classifier.fit(X_train, y_train)
+			scoreTraining = classifier.score(X_train, y_train)
+			scoreTest = classifier.score(X_test, y_test)
+			
+			y_new = classifier.predict(X_test)
+			
+			
+			
+			yNew.append(y_new)
+			yTest.append(y_test)
+			
+			
+			for i in range(0,len(y_new)):
+				cMatrix[y_test[i]][round(y_new[i])]+=1
+				y_new[i]=round(y_new[i])
+
+			print("\ttraining: %.4f, test: %.4f" % (scoreTraining, scoreTest))
+			classifierPerformance.append( scoreTest )
+			
+	
+			F1scoreTest = f1_score(y_test, y_new, average='weighted')
+			F1score.append(F1scoreTest)
+
+		pd.DataFrame(cMatrix).to_csv("./best/cMatrix"+str(classifierIndex)+".csv", header=None, index =None)
+		classifierIndex+=1
+		line ="%s \t %.4f \t %.4f \t %.4f \t %.4f\n" % (classifierName, np.mean(classifierPerformance), np.std(classifierPerformance), np.mean(F1score), np.std(F1score))
+		
+		
+		print(line)
+		fo = open("./best/results.txt", 'a')
+		fo.write( line )
+		fo.close()
+	
+	return
+
+if __name__ == "__main__" :
+	parser = argparse.ArgumentParser(description="Run multiple classifiers based on the best run")
+	parser.add_argument('--folds', type=int, default=10, help='Number of folds (default: 10)')
+	args = parser.parse_args()
+
+	sys.exit( runFeatureReduce(args.folds) )