{"id":18734196,"url":"https://github.com/nico-curti/dnetpro","last_synced_at":"2025-07-27T02:09:36.216Z","repository":{"id":51489227,"uuid":"208441856","full_name":"Nico-Curti/DNetPRO","owner":"Nico-Curti","description":"Discriminant Analysis with Network PROcessing","archived":false,"fork":false,"pushed_at":"2023-12-21T17:20:32.000Z","size":761,"stargazers_count":4,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"master","last_synced_at":"2025-04-02T06:51:15.932Z","etag":null,"topics":["combinatorial-optimization","feature-selection","microarray-data","mrna","network-analysis"],"latest_commit_sha":null,"homepage":"https://dnetpro.readthedocs.io/en/latest","language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"other","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/Nico-Curti.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":".github/CONTRIBUTING.md","funding":null,"license":"LICENSE","code_of_conduct":".github/CODE_OF_CONDUCT.md","threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":"AUTHORS.md","dei":null,"publiccode":null,"codemeta":null}},"created_at":"2019-09-14T13:08:33.000Z","updated_at":"2024-07-30T13:33:59.000Z","dependencies_parsed_at":"2024-11-07T15:12:48.796Z","dependency_job_id":null,"html_url":"https://github.com/Nico-Curti/DNetPRO","commit_stats":null,"previous_names":[],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/Nico-Curti/DNetPRO","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Nico-Curti%2FDNetPRO","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Nico-Curti%2FDNetPRO/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Nico-Curti%2FDNetPRO/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Nico-Curti%2FDNetPRO/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/Nico-Curti","download_url":"https://codeload.github.com/Nico-Curti/DNetPRO/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Nico-Curti%2FDNetPRO/sbom","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":267285750,"owners_count":24064218,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","status":"online","status_checked_at":"2025-07-27T02:00:11.917Z","response_time":82,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["combinatorial-optimization","feature-selection","microarray-data","mrna","network-analysis"],"created_at":"2024-11-07T15:12:42.491Z","updated_at":"2025-07-27T02:09:36.189Z","avatar_url":"https://github.com/Nico-Curti.png","language":"Python","funding_links":[],"categories":[],"sub_categories":[],"readme":"| **Authors**  | **Project** |  **Documentation** | **Build Status** | **License** | **Code Quality** | **Coverage** |\n|:------------:|:-----------:|:------------------:|:----------------:|:-----------:|:----------------:|:------------:|\n| [**N. Curti**](https://github.com/Nico-Curti) | **DNetPRO**\u003cbr/\u003e[![Scientific Reports](https://img.shields.io/badge/Scientific%20Reports-s41598.022.25549.9-g.svg)](https://www.nature.com/articles/s41598-022-25549-9) | [![Doxygen Sphinx](https://github.com/Nico-Curti/DNetPRO/actions/workflows/docs.yml/badge.svg)](https://github.com/Nico-Curti/DNetPRO/actions/workflows/docs.yml) \u003cbr/\u003e [![ReadTheDocs](https://readthedocs.org/projects/dnetpro/badge/?version=latest)](https://dnetpro.readthedocs.io/en/latest/?badge=latest) | [![Linux](https://github.com/Nico-Curti/DNetPRO/actions/workflows/linux.yml/badge.svg)](https://github.com/Nico-Curti/DNetPRO/actions/workflows/linux.yml) \u003cbr/\u003e [![Windows](https://github.com/Nico-Curti/DNetPRO/actions/workflows/windows.yml/badge.svg)](https://github.com/Nico-Curti/DNetPRO/actions/workflows/windows.yml)  \u003cbr/\u003e [![MacOS](https://github.com/Nico-Curti/DNetPRO/actions/workflows/macos.yml/badge.svg)](https://github.com/Nico-Curti/DNetPRO/actions/workflows/macos.yml) \u003cbr/\u003e [![Python](https://github.com/Nico-Curti/DNetPRO/actions/workflows/python.yml/badge.svg)](https://github.com/Nico-Curti/DNetPRO/actions/workflows/python.yml) | [![license](https://img.shields.io/github/license/mashape/apistatus.svg)](https://github.com/Nico-Curti/DNetPRO/blob/master/LICENSE) | [![Codacy Badge](https://app.codacy.com/project/badge/Grade/13ded25898ce4844a2591f1cff7764c8)](https://www.codacy.com/gh/Nico-Curti/DNetPRO/dashboard?utm_source=github.com\u0026amp;utm_medium=referral\u0026amp;utm_content=Nico-Curti/DNetPRO\u0026amp;utm_campaign=Badge_Grade) \u003cbr/\u003e [![Codebeat](https://codebeat.co/badges/0c5129c1-4537-4545-a8e2-07807c6303f5)](https://codebeat.co/projects/github-com-nico-curti-dnetpro-master) | [![codecov](https://codecov.io/gh/Nico-Curti/DNetPRO/branch/master/graph/badge.svg)](https://codecov.io/gh/Nico-Curti/DNetPRO) |\n\n[![GitHub pull-requests](https://img.shields.io/github/issues-pr/Nico-Curti/DNetPRO.svg?style=plastic)](https://github.com/Nico-Curti/DNetPRO/pulls)\n[![GitHub issues](https://img.shields.io/github/issues/Nico-Curti/DNetPRO.svg?style=plastic)](https://github.com/Nico-Curti/DNetPRO/issues)\n\n[![GitHub stars](https://img.shields.io/github/stars/Nico-Curti/DNetPRO.svg?label=Stars\u0026style=social)](https://github.com/Nico-Curti/DNetPRO/stargazers)\n[![GitHub watchers](https://img.shields.io/github/watchers/Nico-Curti/DNetPRO.svg?label=Watch\u0026style=social)](https://github.com/Nico-Curti/DNetPRO/watchers)\n\n\u003ca href=\"https://github.com/UniboDIFABiophysics\"\u003e\n  \u003cdiv class=\"image\"\u003e\n    \u003cimg src=\"https://cdn.rawgit.com/physycom/templates/697b327d/logo_unibo.png\" width=\"90\" height=\"90\"\u003e\n  \u003c/div\u003e\n\u003c/a\u003e\n\n# DNetPRO\n\n## Discriminant Analysis with Network Processing\n\nOfficial implementation of the DNetPRO algorithm published on [Scientific Reports](https://www.nature.com/articles/s41598-022-25549-9) by Curti et al. [![Scientific Reports](https://img.shields.io/badge/Scientific%20Reports-s41598.022.25549.9-g.svg)](https://www.nature.com/articles/s41598-022-25549-9)\n\n* [Overview](#overview)\n* [Theory](#theory)\n* [Prerequisites](#prerequisites)\n* [Installation](#installation)\n* [Efficiency](#efficiency)\n* [Usage](#usage)\n* [Testing](#testing)\n* [Table of contents](#table-of-contents)\n* [Contribution](#contribution)\n* [References](#references)\n* [FAQ](#faq)\n* [Authors](#authors)\n* [License](#license)\n* [Acknowledgment](#acknowledgment)\n* [Citation](#citation)\n\n## Overview\n\n| \u003cimg src=\"https://github.com/Nico-Curti/DNetPRO/blob/master/img/examples.png\" width=600\u003e |\n| -- |\n| **(a)** An example in which single-parameter classification fails in predicting higher-dimension classification performance. Both parameters (*feature1* and *feature2*) badly classify in 1-D, but have a very good performance in 2D. Moreover, classification can be easily interpreted in terms of relative higher/lower expression of both probes. **(b)** Activity of a biological feature (e.g. a gene) as a function of its expression level: top) monotonically increasing, often also discretized to an on/off state; center, bottom) \"windowed\" behavior, in which there are two or more activity states that do not depend monotonically on expression level. X axis: expression level, Y axis, biological state (arbitrary scales). |\n\nMethods that select variables for multi-dimensional signatures based on single-variable performance can have limits in predicting\nhigher-dimensional signature performance.\nAs shown in Fig.[1](https://github.com/Nico-Curti/DNetPRO/blob/master/img/examples.png)(a), in which both variables taken singularly perform poorly, but their performance becomes optimal in a 2-dimensional combination, in terms of linear separation of the two classes.\n\nIt is known that complex separation surfaces characterize classification tasks associated to image and speech recognition, for which Deep Networks are used successfully in recent times, but in many cases biological data, such as gene or protein expression, are more likely characterized by a up/down-regulation behavior (as shown in Fig.[1](https://github.com/Nico-Curti/DNetPRO/blob/master/img/examples.png)(b) top), while more complex behaviors (e.g. a optimal range of activity, Fig.[1](https://github.com/Nico-Curti/DNetPRO/blob/master/img/examples.png)(b) bottom) are much less likely.\nThus, discriminant-based methods (and logistic regression methods alike) can very likely provide good classification performances in these cases (as demonstrated by our results with DNetPRO) if applied in at least\ntwo-dimensional spaces.\nMoreover, the of these methods (that generate very simple class separation surfaces, *i.e.* linear or quadratic) guarantee that a of a signature based on lower-dimensional signatures is feasible.\n\nThis consideration are relevant in particular for microarray data where we face on a small number of samples compared to a huge amount of variables (gene probes).\nThis kind of problem, often called problem (where `N` is the number of features, i.e variables, and `S` is the number of samples), tend to be prone to overfitting and they are classified to ill-posed.\nThe difficulty on the feature extraction can also increase due to noisy variables that can drastically affect the machine learning algorithms.\nOften is difficult to discriminate between noise and significant variables and even more as the number of variables rises.\n\nIn this project we propose a new method of features selection - DNetPRO, *Discriminant Analysis with Network PROcessing* - developed to outperform the mentioned above problems.\nThe method is particularly designed to gene-expression data analysis and it was tested against the most common feature selection techniques.\nThe method was already applied on gene-expression datasets but my work focused on the benchmark of it and on its optimization for Big Data applications.\nThe pipeline algorithm is made by many different steps and only a part of it was designed to biological application: this allow me to apply (part of) the same techniques also in different kind of problems with good results (see [[10.1140/epjds/s13688-018-0168-2](https://doi.org/10.1140/epjds/s13688-018-0168-2)]).\n\n## Theory\n\nThe `DNetPRO` algorithm produces multivariate signatures starting from all the couples of variables analyzed by a Discriminant Analysis.\nFor this reason, it can be classified as a combinatorial method and the computational time for the exploration of variable space is proportional to the square of the number of underlying variables (ranging from `10^3` to `10^5` in a typical high-throughput omics study).\nThis behavior allows to overcome some of the limits of single-feature selection methods and it provides a hard-thresholding approach compared to projection-based variable selection methods.\nThe combinatorial evaluation is the most time-expensive step of the algorithm and it needs an accurate algorithmic implementation for Big Data applications.\nA summary of the algorithm is shown in the following pseudo-code.\n\n\u003e **Data:** Data Matrix (N, S)\\\n\u003e **Result:** List of putative signatures\n\u003e\n\u003e Divide the data into training and test by a Hold-Out method;\n\u003e\n\u003e **FOR** `couple` \u0026larr; (feature_1, feature_2) \u0026in; `Couples` **DO**\n\u003e\u003e \u0026nbsp;\u0026nbsp;\u0026nbsp;\u0026nbsp;Leave-One-Out cross validation;\\\n\u003e\u003e \u0026nbsp;\u0026nbsp;\u0026nbsp;\u0026nbsp;Score estimation using the Classifier;\n\u003e\n\u003e **END**\n\u003e\n\u003e Sorting of the couples in ascending order according to their score;\\\n\u003e Threshold over the couples score (K-best couples);\n\u003e\n\u003e **FOR** `component` \u0026in; `connected_components` **DO**\n\u003e\u003e \u0026nbsp;\u0026nbsp;\u0026nbsp;\u0026nbsp;**IF** `reduction`\\\n\u003e\u003e \u0026nbsp;\u0026nbsp;\u0026nbsp;\u0026nbsp;\u0026nbsp;\u0026nbsp;\u0026nbsp;\u0026nbsp;Iteratively pendant node removal;\\\n\u003e\u003e  \u0026nbsp;\u0026nbsp;\u0026nbsp;\u0026nbsp;**END**\n\u003e\u003e\n\u003e\u003e Signature evaluation using the Classifier;\n\u003e\n\u003e **END**\n\nSo, given an initial dataset, with `S` *samples* (e.g. cells or patients) each one described by $N$ observations (our *variables*, e.g. gene or protein expression profiles), the signature identification can be summarized with the following steps:\n\n1. Separation of available data into a `training` and a `test` set (typically 66/33, or 80/20).\n2. Estimation of the classification performance according to the desired metric on the training set of all $S(S−1)/2$ `feature pairs` through a computationally fast and reproducible cross-validation procedure (leave-one-out cross validation was chosen).\n  In the applications provided in this work we used the Matthew Coefficient as a metric for performance estimation of a discriminant analysis.\n  The results are mapped into a fully connected symmetric weighted network, with nodes corresponding to features and link weights corresponding to performance of the node couples.\n3. Selection of top-performing pairs through a hard-thresholding procedure, that removes links (and nodes) from the initial fully connected network: every connected component obtained is considered as a putative classification signature.\n  The threshold value can be tuned according to a desired minimum-performance value or considering a minimum number of nodes/features in the signature.\n  The threshold value can be determined also by testing each of the obtained performances as a possible cut-off via a cross validation of the entire signature extraction procedure.\n4. [**Optional**] In the hypothesis that node degree is associated to the global feature performance in combination with the other features, to reduce the size of an identified signature, the pendant nodes of the signature network, *i.e.*, nodes with degree equal to one, can be removed.\n  This procedure can be applied once, or recursively until the core network, *i.e.*, a network with all nodes with at least two links, is reached.\n  We have tested the efficacy of this empirical approach in some real cases [[10.3233/JAD-190480](https://doi.org/10.3233/JAD-190480), [10.1007/BF02951333](https://doi.org/10.1007/BF02951333)], obtaining a smaller-dimensional signature with comparable performance, even if there is not a solid theoretical basis supporting this procedure.\n5. [**Optional**] The classifier used in the feature selection and the final classification does not need to be a Discriminant\nAnalysis classifier, but can in principle be any classifier. Moreover, the classifier used in the feature selection does not\nneed to be the same one used for the final evaluation of the obtained signature.\n6. **(a)** All signatures are applied onto the test set to estimate their performance, producing more than one final signature.\n\u003e **OR**\n6. **(b)** To identify a unique best performing signature, a further cross validation step can be applied, with a further `dataset` splitting into training (to identify the multiple signatures), test (to identify the best signature) and validation set (to evaluate the best signature performance).\n\nWe would stress that this method is completely independent to the choose of the classification algorithm, but, from a biological point-of-view, a simple one is preferable to keep an easy interpretability of the results.\nThe geometrical simplicity of the resulting class-separation surfaces, in fact, allows an easier interpretation of the results, as compared to very powerful but black-box methods like nonlinear-kernel SVM or Neural Networks.\nThese are the reasons which lead us to use very simple classifier methods in our biological applications as diag-quadratic Discriminant Analysis or Quadratic Discriminant Analysis.\nBoth these methods allow fast computation and an easy interpretation of the results.\nA linear separation might not be common in some classification problems (e.g. image classification), but it is very likely in biological systems, where many responses to perturbation consist in an increase or decrease of variable values (e.g. expression of genes or proteins, see Fig.[1](https://github.com/Nico-Curti/DNetPRO/blob/master/img/expression.svg)(b)).\n\nA second direct gain by the couples evaluation is related to the network structure: the `DNetPRO` network signatures allow a hierarchical ranking of features according to their centrality compared to other methods.\nThe underlying network structure of the signature could suggests further methods to improve its dimensionality reduction based on network topological properties to fit real application needs, and it could help to evaluate the cooperation of variables for the class identification.\n\nIn the end, we remark that our signatures have a purely statistical relevance by being generated with a purpose of maximal classification performance, but sometimes the selected features (e.g. genes, DNA loci, metabolites) can be of clinical and biological interest, helping to improve knowledge on the mechanism associated to the studied phenomenon [[10.1101/gr.155192.113](https://doi.org/10.1101/gr.155192.113), [10.1200/JCO.2008.19.2542](https://doi.org/10.1200/JCO.2008.19.2542), [10.1101/gr.193342.115](https://doi.org/10.1101/gr.193342.115), [10.18632/oncotarget.5718](https://doi.org/10.18632/oncotarget.5718)].\n\n## Prerequisites\n\nC++ supported compilers:\n\n![gcc version](https://img.shields.io/badge/gcc-4.8.5%20|%204.9.*%20|%205.*%20|%206.*%20|%207.*%20|%208.*%20|%209.*-yellow.svg)\n\n![clang version](https://img.shields.io/badge/clang-3.*%20|%204.*%20|%205.*%20|%206.*%20|%207.*%20|-red.svg)\n\n![msvc version](https://img.shields.io/badge/msvc-vs2017%20x86%20|%20vs2017%20x64|%20vs2019%20x86%20|%20vs2019%20x64-blue.svg)\n\nThe `DNetPRO` project is written in `C++` and it supports also older standard versions (std=c++1+).\nThe package installation can be performed via [`CMake`](https://github.com/Nico-Curti/DNetPRO/blob/master/CMakeLists.txt).\nThe `CMake` installer provides also a `DNetPRO.pc`, useful if you want link to the `DNetPRO` using `pkg-config`.\n\nThe only dependency of the `C++` version of the project is given by the [`parse_args`](http://github.com/Nico-Curti/parse_args) library.\nA complete list of instruction for its installation is available [here](https://github.com/Nico-Curti/parse_args/README.md).\nIf you prefer, you can also use the [`submodule`](https://github.com/Nico-Curti/DNetPRO/blob/master/modules/) version of the library and leave to the current `CMake` the responsibility of its installation.\nIn this case you need to provide to the `cmake` command line the extra-flag of `FORCE_USE_SUBMODULES:BOOL=ON` (see next for further details about it).\n\nYou can also use the `DNetPRO` package in `Python` using the `Cython` wrap provided inside this project.\nThe only requirements are the following:\n\n* numpy \u003e= 1.15\n* networkx \u003e= 2.2\n* cython \u003e= 0.29\n* scikit-learn\u003e=1.3.2\n* pandas \u003e= 0.24.2\n\nThe `Cython` version can be built and installed via `CMake` enabling the `-DPYWRAP` variable.\nYou can use also the `DNetPRO` package in `Python` using the `Cython` wrap provided inside this project.\nThe `Python` wrap guarantees also a good integration with the other common Machine Learning tools provided by `scikit-learn` `Python` package; in this way you can use the `DNetPRO` algorithm as an equivalent alternative also in other pipelines.\nLike other Machine Learning algorithm also the `DNetPRO` one depends on many parameters, i.e its hyper-parameters, which has to be tuned according to the given problem.\nThe `Python` wrap of the library was written according to `scikit-optimize` `Python` package to allow an easy hyper-parameters optimization using the already implemented classical methods.\n\n## Installation\n\n1) Follow your system prerequisites (below)\n\n2) Clone the `DNetPRO` package from this repository, or download a stable release\n\n```bash\ngit clone https://github.com/Nico-Curti/DNetPRO.git\ncd DNetPRO\ngit submodule update --init --recursive\n```\n\n3) `DNetPRO` could be built with CMake and Make or with the *build* scripts in the project.\nExample:\n\n|              |  **Linux**    |  **MacOS**    |  **Windows**  |\n|:------------:|:--------------|:--------------|:--------------|\n| **Script**   | `./build.sh`  | `./build.sh`  | `./build.ps1` |\n\n\u003cdetails\u003e\u003csummary\u003e\u003cb\u003eUbuntu\u003c/b\u003e\u003c/summary\u003e\n\u003cp\u003e\n\n1) Define a work folder, which we will call WORKSPACE in this tutorial: this could be a \"Code\" folder in our home, a \"c++\" folder on our desktop, whatever you want. Create it if you don't already have, using your favourite method (mkdir in bash, or from the graphical interface of your distribution). We will now define an environment variable to tell the system where our folder is. Please note down the full path of this folder, which will look like `/home/$(whoami)/code/`\n\n```bash\necho -e \"\\n export WORKSPACE=/full/path/to/my/folder \\n\" \u003e\u003e ~/.bashrc\nsource ~/.bashrc\n```\n\n2) Open a Bash terminal and type the following commands to install all the prerequisites.\n\n```bash\nsudo add-apt-repository ppa:ubuntu-toolchain-r/test\nsudo apt-get update\nsudo apt-get install -y gcc-8 g++-8\n\nwget --no-check-certificate https://cmake.org/files/v3.13/cmake-3.13.1-Linux-x86_64.tar.gz\ntar -xzf cmake-3.13.1-Linux-x86_64.tar.gz\nexport PATH=$PWD/cmake-3.13.1-Linux-x86_64/bin:$PATH\n\nsudo apt-get install -y make git dos2unix ninja-build\ngit config --global core.autocrlf input\ngit clone https://github.com/physycom/sysconfig\n```\n\n3) Build the project with CMake (enable or disable OMP with the define **-DOMP**:\n\n```bash\ncd $WORKSPACE\ngit clone https://github.com/Nico-Curti/DNetPRO\ncd DNetPRO\ngit submodule update --init --recursive\n\nmkdir -p build\ncd build\n\ncmake ..\nmake -j\ncmake --build . --target install\ncd ..\n```\n\u003c/p\u003e\n\u003c/details\u003e\n\n\u003cdetails\u003e\u003csummary\u003e\u003cb\u003emacOS\u003c/b\u003e\u003c/summary\u003e\n\u003cp\u003e\n\n1) If not already installed, install the XCode Command Line Tools, typing this command in a terminal:\n\n```bash\nxcode-select --install\n```\n\n2) If not already installed, install Homebrew following the [official guide](https://brew.sh/index_it.html).\n\n3) Open the terminal and type these commands\n\n```bash\nbrew update\nbrew upgrade\nbrew install gcc@8\nbrew install cmake make git ninja\n```\n\n4) Define a work folder, which we will call WORKSPACE in this tutorial: this could be a \"Code\" folder in our home, a \"c++\" folder on our desktop, whatever you want. Create it if you don't already have, using your favourite method (mkdir in bash, or from the graphical interface in Finder). We will now define an environment variable to tell the system where our folder is. Please note down the full path of this folder, which will look like /home/$(whoami)/code/\n\n5) Open a Terminal and type the following command (replace /full/path/to/my/folder with the previous path noted down)\n\n```bash\necho -e \"\\n export WORKSPACE=/full/path/to/my/folder \\n\" \u003e\u003e ~/.bash_profile\nsource ~/.bash_profile\n```\n\n6) Build the project with CMake (enable or disable OMP with the define **-DOMP**:\n\n```bash\ncd $WORKSPACE\ngit clone https://github.com/Nico-Curti/DNetPRO\ncd DNetPRO\ngit submodule update --init --recursive\n\nmkdir -p build\ncd build\n\ncmake ..\nmake -j\ncmake --build . --target install\ncd ..\n```\n\n\u003c/p\u003e\n\u003c/details\u003e\n\n\u003cdetails\u003e\u003csummary\u003e\u003cb\u003eWindows (7+)\u003c/b\u003e\u003c/summary\u003e\n\u003cp\u003e\n\n1) Install Visual Studio 2017 from the [official website](https://www.visualstudio.com/)\n\n2) Open your Powershell with Administrator privileges, type the following command and confirm it:\n\n```PowerShell\nPS \\\u003e                 Set-ExecutionPolicy unrestricted\n```\n\n3) If not already installed, please install chocolatey using the [official guide](http://chocolatey.org)\n\n4) If you are not sure about having them updated, or even installed, please install `git`, `cmake` and an updated `Powershell`. To do so, open your Powershell with Administrator privileges and type\n\n```PowerShell\nPS \\\u003e                 cinst -y git cmake powershell\n```\n\n5) Restart the PC if required by chocolatey after the latest step\n\n6) Install PGI 18.10 from the [official website](https://www.pgroup.com/products/community.htm) (the community edition is enough and is free; NOTE: install included MS-MPI, but avoid JRE and Cygwin)\n\n7) Activate license for PGI 18.10 Community Edition (rename the file `%PROGRAMFILES%\\PGI\\license.dat-COMMUNITY-18.10` to `%PROGRAMFILES%\\PGI\\license.dat`) if necessary, otherwise enable a Professional License if available\n\n8) Define a work folder, which we will call `WORKSPACE` in this tutorial: this could be a \"Code\" folder in our home, a \"cpp\" folder on our desktop, whatever you want. Create it if you don't already have, using your favourite method (mkdir in Powershell, or from the graphical interface in explorer). We will now define an environment variable to tell the system where our folder is. Please note down its full path. Open a Powershell (as a standard user) and type\n\n```PowerShell\nPS \\\u003e                 rundll32 sysdm.cpl,EditEnvironmentVariables\n```\n\n9) In the upper part of the window that pops-up, we have to create a new environment variable, with name `WORKSPACE` and value the full path noted down before.\nIf it not already in the `PATH` (this is possible only if you did it before), we also need to modify the \"Path\" variable adding the following string (on Windows 10 you need to add a new line to insert it, on Windows 7/8 it is necessary to append it using a `;` as a separator between other records):\n\n```cmd\n                      %PROGRAMFILES%\\CMake\\bin\n```\n\n10) If `vcpkg` is not installed, please follow the next procedure, otherwise please jump to #12\n\n```PowerShell\nPS \\\u003e                 cd $env:WORKSPACE\nPS Code\u003e              git clone https://github.com/Microsoft/vcpkg.git\nPS Code\u003e              cd vcpkg\nPS Code\\vcpkg\u003e        .\\bootstrap-vcpkg.bat\n```\n\n11) Open a Powershell with Administrator privileges and type\n\n```PowerShell\nPS \\\u003e                 cd $env:WORKSPACE\nPS Code\u003e              cd vcpkg\nPS Code\\vcpkg\u003e        .\\vcpkg integrate install\n```\n\n12) Open a Powershell and build `DNetPRO` using the `build.ps1` script\n\n```PowerShell\nPS \\\u003e                 cd $env:WORKSPACE\nPS Code\u003e              git clone https://github.com/Nico-Curti/DNetPRO\nPS Code\u003e              cd DNetPRO\nPS Code\\DNetPRO\u003e      .\\build.ps1\n```\n\n\u003c/p\u003e\n\u003c/details\u003e\n\n### CMake C++ installation\n\nWe recommend the use of `CMake` for the installation since it is the most automated way to reach your needs.\nFirst of all make sure you have a sufficient version of `CMake` installed (3.9 minimum version required).\nIf you are working on a machine without root privileges and you need to upgrade your `CMake` version a valid solution to overcome your problems is provided [here](https://github.com/Nico-Curti/Shut).\n\nWith a valid `CMake` version installed first of all clone the project as:\n\n```bash\ngit clone https://github.com/Nico-Curti/DNetPRO\ncd DNetPRO\ngit submodule update --init --recursive\n```\n\nThe you can build the `DNetPRO` package with\n\n```bash\nmkdir -p build\ncd build \u0026\u0026 cmake .. \u0026\u0026 cmake --build . --target install\n```\n\nor more easily\n\n```bash\n./build.sh\n```\n\nif you are working on a Windows machine the right script to call is the [`build.ps1`](https://Nico-Curti/DNetPRO/blob/master/build.ps1).\n\nThe `CMake` command line can be customized according to the following parameters:\n\n* `-DOMP:BOOL` : Enable/Disable the OpenMP support for multi-threading computation\n* `-DBUILD_DOCS:BOOL` : Enable/Disable the build of docs using Doxygen and Sphinx\n* `-DPYWRAP:BOOL` : Enable/Disable the build of Python wrap of the library via Cython (see next section for Python requirements)\n* `-DFORCE_USE_SUBMODULES:BOOL` : Force the use of submodules or the already installed versions of the required libraries.\n\n| :triangular_flag_on_post: Note |\n|:-------------------------------|\n| All the variables above are set to `OFF` by default! |\n\n| :triangular_flag_on_post: NOTE |\n|:-------------------------------|\n| If you are working under Windows OS and you are familiar with vcpkg package, you can find the series of `ports` script for vcpkg integration of `parseargs` in the relative directory.\u003cbr\u003eCopying those scripts in the vcpkg project folder you can install both the libraries via vcpkg!\u003cbr\u003eThen you should use them directly via `CMAKE_TOOLCHAIN_FILE` |\n\n| :warning: WARNING |\n|:------------------|\n| If the `ParseArgs` library is not found during the building process, the submodules of the current project directory are used.\u003cbr\u003eYou can manually force the use of submodules using the `-DFORCE_USE_SUBMODULE:BOOL=ON` flag during the configuration.\u003cbr\u003eIf you have manually installed the libraries you can pass to the `CMake` configuration the variable `-DParseArgs_DIR:PATH=/path/to/parseargs/share/parseargs`. |\n\n### Python installation\n\nPython version supported : ![Python version](https://img.shields.io/badge/python-3.5|3.6|3.7|3.8-blue.svg)\n\nThe `Python` installation can be performed with or without the `C++` installation.\nThe `Python` installation is always executed using [`setup.py`](https://github.com/Nico-Curti/DNetPRO/blob/master/setup.py) script.\n\nIf you have already build the `DNetPRO` `C++` library the installation is performed faster and the `Cython` wrap directly links to the last library installed.\nOtherwise the full list of dependencies is build.\n\nIn both cases the installation steps are:\n\n```mermaid\ngraph LR;\n    A(Install\u003cbr\u003eRequirements) --\u003e|python -m pip install -r requirements.txt| B(Install\u003cbr\u003eDNetPRO)\n    B --\u003e|python setup.py install| C(Package\u003cbr\u003eInstall)\n    B --\u003e|python setup.py develop --user| D(Development\u003cbr\u003eMode)\n```\n\n| :warning: WARNING |\n|:------------------|\n| The installation of the `Python` modules requires the `CMake` support and all the listed above libraries.\u003cbr\u003eIf you are working under *Window OS* we require the usage of `VCPKG` for the installation of the libraries and a precise configuration of the environment variables.\u003cbr\u003eIn particular you need to set the variables `VCPKG_ROOT=/path/to/vcpkg/rootdir/` and `VCPKG_DEFAULT_TRIPLET=x64-windows`.\u003cbr\u003eA full working example of OS configuration can be found in the CI actions of the project, available [here](https://github.com/Nico-Curti/DNetPRO/blob/main/.github/workflows/) |\n\n| :warning: WARNING |\n|:------------------|\n| All the `CMake` flags are set internally in the `setup.py` script with default values.\u003cbr\u003eYou can manually turn on/off the multi-threading support passing the flag `--omp` at the setup command line, *i.e.* `python setup.py develop --user --omp` |\n\n## Efficiency\n\nAs described in the above sections, the `DNetPRO` is a combinatorial algorithm and thus it requires a particular accuracy in the code implementation to optimize as much as possible the computational performances.\nThe theoretical optimization strategies, described up to now, have to be proved by quantitative measures.\n\nThe time evaluation was performed using the `Cython` (`C++` wrap) implementation against the pure `Python` (naive) implementation showed in the previous snippet.\nThe time evaluation was performed using the `timing` `Python` package in which we can easily simulate multiple runs of a given algorithm.\nIn our simulations, we monitored the three main parameters related to the algorithm efficiency: the number of samples, the number of variables and (as we provided a parallel multi-threading implementation) the number of threads used.\nFor each combination of parameters, we performed 30 runs of both algorithms and we extracted the minimum execution time.\nThe tests were performed on a classical bioinformatics server (128 GB RAM memory and 2 CPU E5-2620, with 8 cores each).\nThe obtained results are shown in following Figure.\nIn each plot, we fixed two variables and we evaluated the remaining one.\n\n| Features | Samples | Threads |\n| -------- | ------- | ------- |\n| ![features](https://github.com/Nico-Curti/DNetPRO/blob/master/img/features_timing.svg) | ![samples](https://github.com/Nico-Curti/DNetPRO/blob/master/img/samples_timing.svg) | ![threads](https://github.com/Nico-Curti/DNetPRO/blob/master/img/nth_timing.svg) |\n| Execution time of the `DNetPRO` algorithm. We compare the execution time between pure-`Python` (orange) and `Cython` (blue, `C++` wrap) implementations. Execution time in function of the number of variables (the number of samples and the number of threads are kept fixed). | Execution time of the `DNetPRO` algorithm. We compare the execution time between pure-`Python` (orange) and `Cython` (blue, `C++` wrap) implementation. Execution time in function of the number of samples (the number of variables and the number of threads are kept fixed). | Execution time of the `DNetPRO` algorithm. We compare the execution time between pure-`Python` (orange) and `Cython` (blue, `C++` wrap) implementation. Execution time in function of the number of threads (the number of variables and the number of samples are kept fixed). |\n\nIn all our simulations, the efficiency of the (optimized) `Cython` version is easily visible and the gap between the two implementations reached more than `10^4` seconds.\nOn the other hand, it is important to highlight the scalability of the codes against the various parameters.\nWhile the code performances scale quite well with the number of features (Fig. [1](https://github.com/Nico-Curti/DNetPRO/blob/master/img/features_timing.svg)) in both the implementations, we have a different trend varying the number of samples (Fig. [2](https://github.com/Nico-Curti/DNetPRO/blob/master/img/samples_timing.svg)): the `Cython` rend starts to saturate almost immediately, while the computational time of the `Python` implementation continues to grow.\nThis behavior highlights the results of the optimizations performed on the `Cython` version which allows the application of the `DNetPRO` algorithm also to larger datasets without loosing performances.\nAn opposite behavior is found monitoring the number of threads (ref Fig. [3](https://github.com/Nico-Curti/DNetPRO/blob/master/img/nth_timing.svg)): the `Python` version scales quite well with the number of threads, while `Cython` trend is more unstable.\nThis behavior is probably due to a non-optimal schedule in the parallel section: the work is not equally distributed along the available threads and it penalizes the code efficiency, creating a bottleneck related to the slowest thread.\nThe above results are computed considering a number of features equal to 90 and, thus, the parallel section distributes the 8100 (`N x N`) iterations along the available threads: when the number of iterations is proportional to the number of threads used (12, 20 and 30 in our case), we have a maximization of the time performances.\nDespite of this, the computational efficiency of the `Cython` implementation is so much better than the `Python` one that its usage is indisputable.\n\n## Usage\n\nYou can use the `DNetPRO` algorithm into pure-Python modules or inside your C++ application.\n\n### C++ Version\n\nThe easiest usage of `DNetPRO` algorithm is given by the example provided in the [example](https://github.com/Nico-Curti/DNetPRO/blob/master/example) folder.\nThis script includes an easy-to-use command line to run the `DNetPRO` algorithm on a dataset stored into a file.\n\n```\n./bin/DNetPRO_couples\nUsage: ./DNetPRO_couples -f \u003cstd :: string\u003e -o \u003cstd :: string\u003e [-frac \u003cfloat\u003e ] [-bin \u003cbool\u003e ] [-verbose \u003cbool\u003e ] [-probeID \u003cbool\u003e ] [-nth \u003cint\u003e ]\n\nDNetPRO couples evaluation 2.0\n\noptional arguments:\n        -f,   --input                   Input filename\n        -o,   --output                  Output filename\n        -s,   --frac                    Fraction of results to save\n        -b,   --bin                     Enable Binary output\n        -q,   --verbose                 Enable stream output\n        -p,   --probeID                 ProbeID name to skip\n        -n,   --nth                     Number of threads to use\n```\n\nIf you are interested in using `DNetPRO` algorithm inside your code you can simply import the [`dnetpro_couples.h`](https://github.com/Nico-Curti/DNetPRO/blob/master/include/dnetpro_couples.h) and call the `dnetpro_couples` function.\n\nThen all the results will be stored into a easy-to-manage [`score`](https://github.com/Nico-Curti/DNetPRO/blob/master/include/score.h) object.\n\n### Python Version\n\nThe `DNetPRO` object is totally equivalent to a `scikit-learn` feature-selection method and thus it provides the member functions `fit` (to train your model) and `predict` (to test a trained model on new samples).\n\nFirst of all you need to import the `DNetPRO` modules and then simply call the training/testing functions.\n\n```python\nimport pandas as pd\nfrom DNetPRO import DNetPRO\nfrom sklearn.naive_bayes import GaussianNB\nfrom sklearn.model_selection import train_test_split\n\nX = pd.read_csv('./example/data.txt', sep='\\t', index_col=0, header=0)\ny = np.asarray(X.columns.astype(float).astype(int))\nX = X.transpose()\n\nX_train, X_test, y_train, y_test = train_test_split(X.values, y, test_size=0.33, random_state=42)\n\ndnet = DNetPRO(estimator=GaussianNB(), n_jobs=4, verbose=True)\n\nXnew = dnet.fit_transform(X_train, y_train)\nprint('Best Signature: {}'.format(dnet.get_signature()[0]))\nprint('Score: {:.3f}'.format(dnet.score(X_test, y_test)))\n```\n\n## Testing\n\nThe Python version of the package is tested using [`pytest`](https://docs.pytest.org/en/latest/).\nTo install the package in development mode you need to add also this requirement:\n\n* pytest == 3.0.7\n\nThe full list of python test scripts can be found [here](https://github.com/Nico-Curti/DNetPRO/blob/master/DNetPRO/test).\n\n## Table of contents\n\nDescription of the folders related to the `C++` version.\n\n| **Directory**  |  **Description** |\n|:--------------:|:-----------------|\n| [example](https://github.com/Nico-Curti/DNetPRO/blob/master/example) | Example script for the `C++` version of the code. Use the command line helper for a full description of the required parameters. |\n| [hpp](https://github.com/Nico-Curti/DNetPRO/blob/master/hpp)         | Implementation of the `C++` template functions and objects used in the `DNetPRO` algorithm.                                       |\n| [include](https://github.com/Nico-Curti/DNetPRO/blob/master/include) | Definition of the `C++` function and objects used in the `DNetPRO` algorithm.                                                    |\n| [src](https://github.com/Nico-Curti/DNetPRO/blob/master/src)         | Implementation of the `C++` functions and objects used in the `DNetPRO` algorithm.                                               |\n\nDescription of the folders related to the `Python` version (base directory `DNetPRO`).\n\n| **Directory**  |  **Description** |\n|:--------------:|:-----------------|\n| [example](https://github.com/Nico-Curti/DNetPRO/blob/master/DNetPRO/example) | `Python` version of the `C++` example.      |\n| [lib](https://github.com/Nico-Curti/DNetPRO/blob/master/DNetPRO/lib)         | List of `Cython` definition files.          |\n| [source](https://github.com/Nico-Curti/DNetPRO/blob/master/DNetPRO/source)   | List of `Cython` implementation objects.    |\n| [test](https://github.com/Nico-Curti/DNetPRO/blob/master/DNetPRO/test)       | List of test scripts for the `Python` wraps.|\n\nDescription of the folders containing the scripts used for the paper simulations.\n\n| **Directory**  |  **Description** |\n|:--------------:|:-----------------|\n| [toy](https://github.com/Nico-Curti/DNetPRO/blob/master/toy)           | Implementation of the `Python` scripts used for the simulations on synthetic datasets. |\n| [pipeline/TCGA](https://github.com/Nico-Curti/DNetPRO/blob/master/toy) | Implementation of the `Python` scripts used for the simulations on the TCGA datasets.  |\n| [timing](https://github.com/Nico-Curti/DNetPRO/blob/master/timing)     | Implementation of the `Python` scripts for the performances evaluation.           |\n\n## Contribution\n\nAny contribution is more than welcome :heart:. Just fill an [issue](https://github.com/Nico-Curti/DNetPRO/blob/master/.github/ISSUE_TEMPLATE/ISSUE_TEMPLATE.md) or a [pull request](https://github.com/Nico-Curti/DNetPRO/blob/master/.github/PULL_REQUEST_TEMPLATE/PULL_REQUEST_TEMPLATE.md) and we will check ASAP!\n\nSee [here](https://github.com/Nico-Curti/DNetPRO/blob/master/.github/CONTRIBUTING.md) for further informations about how to contribute with this project.\n\n## References\n\n\u003cblockquote\u003e Boccardi, Virginia et al. Cognitive Decline and Alzheimer's Disease in Old Age: A Sex-Specific Cytokinome Signature. 1 Jan. 2019 : 911 – 918. https://doi.org/10.3233/JAD-190480 \u003c/blockquote\u003e\n\u003cblockquote\u003e Chen, B., Hong, J. \u0026 Wang, Y. The minimum feature subset selection problem. J. of Comput. Sci. \u0026 Technol. 12, 145–153 (1997). https://doi.org/10.1007/BF02951333 \u003c/blockquote\u003e\n\u003cblockquote\u003e Mizzi, C., Fabbri, A., Rambaldi, S. et al. Unraveling pedestrian mobility on a road network using ICTs data during great tourist events. EPJ Data Sci. 7, 44 (2018). https://doi.org/10.1140/epjds/s13688-018-0168-2 \u003c/blockquote\u003e\n\u003cblockquote\u003e Belkin, M., Niyogi, P. Semi-Supervised Learning on Riemannian Manifolds. Machine Learning 56, 209–239 (2004). https://doi.org/10.1023/B:MACH.0000033120.25363.1e \u003c/blockquote\u003e\n\u003cblockquote\u003e Miao, Z., Balzer, M.S., Ma, Z. et al. Single cell regulatory landscape of the mouse kidney highlights cellular differentiation programs and disease targets. Nat Commun 12, 2277 (2021). https://doi.org/10.1038/s41467-021-22266-1 \u003c/blockquote\u003e\n\u003cblockquote\u003e Levine JH, Simonds EF, Bendall SC, Davis KL, Amir el-AD, Tadmor MD, Litvin O, Fienberg HG, Jager A, Zunder ER, Finck R, Gedman AL, Radtke I, Downing JR, Pe'er D, Nolan GP. Data-Driven Phenotypic Dissection of AML Reveals Progenitor-like Cells that Correlate with Prognosis. Cell. 2015 Jul 2;162(1):184-97. doi: 10.1016/j.cell.2015.05.047. Epub 2015 Jun 18. PMID: 26095251; PMCID: PMC4508757. \u003c/blockquote\u003e\n\u003cblockquote\u003e Katia Scotlandi, Daniel Remondini, Gastone Castellani, Maria Cristina Manara, Filippo Nardi, Lara Cantiani, Mirko Francesconi, Mario Mercuri, Anna Maria Caccuri, Massimo Serra, Sakari Knuutila, and Piero Picci, Journal of Clinical Oncology 2009 27:13, 2209-2216 \u003c/blockquote\u003e\n\u003cblockquote\u003e Cenik C, Cenik ES, Byeon GW, Grubert F, Candille SI, Spacek D, Alsallakh B, Tilgner H, Araya CL, Tang H, Ricci E, Snyder MP. Integrative analysis of RNA, translation, and protein levels reveals distinct regulatory variation across humans. Genome Res. 2015 Nov;25(11):1610-21. doi: 10.1101/gr.193342.115. Epub 2015 Aug 21. PMID: 26297486; PMCID: PMC4617958. \u003c/blockquote\u003e\n\u003cblockquote\u003e Terragna C., Remondini D., Martello M., Zamagni E., Pantani L., Patriarca F., Pezzi A., Levi G., Offidani M., Proserpio I., Sabbata G., Tacchetti P., Cangialosi C., et al The genetic and genomic background of multiple myeloma patients achieving complete response after induction therapy with bortezomib, thalidomide and dexamethasone (VTD). Oncotarget. 2016; 7: 9666-9679. Retrieved from https://www.oncotarget.com/article/5718/text/ \u003c/blockquote\u003e\n\n## FAQ\n\n* **How can I properly set the C++ compiler for the Python installation?**\n\nIf you are working on a Ubuntu machine pay attention to properly set the environment variables related to the `C++` compiler.\nFirst of all take care to put the compiler executable into your environmental path:\n\n```bash\nls -ltA /usr/bin | grep g++\n```\n\nThen you can simply use the command to properly set the right aliases/variables\n\n```bash\nexport CXX=/usr/bin/g++\nexport CC=/usr/bin/gcc\n```\n\nbut I suggest you to put those lines into your `.bashrc` file (one for all):\n\n```bash\necho \"export CC=/usr/bin/gcc\" \u003e\u003e ~/.bashrc\necho \"export CXX=/usr/bin/g++\" \u003e\u003e ~/.bashrc\n```\n\nI suggest you to not use the default `Python` compiler (aka `x86_64-linux-gnu-g++`) since it can suffer of many issues during the compilation if it is not manually customized.\n\n| :triangular_flag_on_post: Note |\n|:-------------------------------|\n| If you are working under Windows OS a complete guide on how to properly configure your MSVC compiler can be found [here](https://github.com/physycom/sysconfig) |\n\n* **I installed the `DNetPRO` Python package following the instructions but I have an `ImportError` when I try to import the package as in the examples**\n\nThis error is due a missing environment variable (which is not automatically set by the installation script).\nAll the `C++` libraries are searched into the OS directory tree starting from the information/paths hinted by the `LD_LIBRARY_PATH` environment variable.\nWhen you install the `DNetPRO` library the produced `.so`, `.dll`, `.dylib` files are saved into the `lib` directory created into the project root directory.\nAfter the installation you must add this directory into the searching path.\nYou can add this information editing the configuration file of your `Unix`-like system, i.e\n\n```bash\necho \"export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/path/to/DNetPRO/project/directory/lib/\" \u003e\u003e ~/.bashrc\necho \"export DYLD_LIBRARY_PATH=$DYLD_LIBRARY_PATH:/path/to/DNetPRO/project/directory/lib/\" \u003e\u003e ~/.bashrc\n```\n\nor adding the `LD_LIBRARY_PATH` to your set of environment variables (especially for `Windows` users).\n\n* **I installed the `DNetPRO` C++ library with the `FORCE_USE_SUBMODULES:BOOL=ON` flag and now I don't find the installed libraries and header files**\n\nThe `DNetPRO` was developed as standalone library, also if it depends by other external libraries.\nAll the dependencies are stored as submodule packages, and they could be installed *before* the `DNetPRO` installation (according to the documentation of the libraries) or alongside it, forcing the usage of submodules.\nIf the `FORCE_USE_SUBMODULES` is enabled, the installation uses the local versions of submodules libraries and, therefore, the outputs are sent to the submodule `share` and `lib` folders.\nThis behavior is not a real issue of the package, since following a \"classical\" installation, *i.e.* with all the requirements pre-installed, the outputs are correctly set.\nA correct output destination is achieved also installing the library via `vcpkg` (see next FAQ for more details about it).\n\n* **How can I install the library via `VCPKG` dependency manager?**\n\nThe `DNetPRO` library is not yet supported via `vcpkg` (I have not submitted any PR yet).\nHowever, in the [`cmake`](https://github.com/Nico-Curti/DNetPRO/blob/master/cmake) folder you can find a complete directory-tree named `vcpkg`.\nYou can simply copy\u0026paste the entire `vcpkg` folder over the original (cloned [here](https://github.com/microsoft/vcpkg)) project to manage the entire installation of the library *also* via vcpkg.\n\n| :triangular_flag_on_post: Note |\n|:-------------------------------|\n| Since no releases have been published yet, the [`portfile`](https://github.com/Nico-Curti/DNetPRO/blob/master/cmake/ports/DNetPRO/portfile.cmake) is not complete and you need to manually set the `REF` and `SHA512` variables! |\n\n| :warning: WARNING |\n|:------------------|\n| All the submodule dependencies provide the same `vcpkg` \"support\" via copy\u0026paste. For submodules not released yet, the editing of the related variables is mandatory! |\n\n## Authors\n\n* \u003cimg src=\"https://avatars0.githubusercontent.com/u/24650975?s=400\u0026v=4\" width=\"25px\"\u003e **Nico Curti** [git](https://github.com/Nico-Curti), [unibo](https://www.unibo.it/sitoweb/nico.curti2)\n* \u003cimg src=\"https://avatars2.githubusercontent.com/u/1419337?s=400\u0026v=4\" width=\"25px;\"/\u003e **Enrico Giampieri** [git](https://github.com/EnricoGiampieri), [unibo](https://www.unibo.it/sitoweb/enrico.giampieri)\n* \u003cimg src=\"https://www.unibo.it/uniboweb/utils/UserImage.aspx?IdAnagrafica=236217\u0026IdFoto=bf094429\" width=\"25px\"\u003e **Gastone Castellani** [unibo](https://www.unibo.it/sitoweb/gastone.castellani)\n* \u003cimg src=\"https://avatars2.githubusercontent.com/u/25343321?s=400\u0026v=4\" width=\"25px\"\u003e **Daniel Remondini** [git](https://github.com/dremondini), [unibo](https://www.unibo.it/sitoweb/daniel.remondini)\n\nSee also the list of [contributors](https://github.com/Nico-Curti/DNetPRO/contributors) [![GitHub contributors](https://img.shields.io/github/contributors/Nico-Curti/DNetPRO.svg?style=plastic)](https://github.com/Nico-Curti/DNetPRO/graphs/contributors/) who participated in this project.\n\n## License\n\nThe `DNetPRO` package is licensed under the MIT \"Expat\" License. [![License](https://img.shields.io/github/license/mashape/apistatus.svg)](https://github.com/Nico-Curti/DNetPRO/blob/master/LICENSE)\n\n### Acknowledgment\n\nThanks goes to all contributors of this project.\n\n### Citation\n\nIf you have found `DNetPRO` helpful in your research, please consider citing the original paper\n\n```BibTex\n@article{Curti2022,\n  author={Curti, Nico and Levi, Giuseppe and Giampieri, Enrico and Castellani, Gastone and Remondini, Daniel},\n  title={A network approach for low dimensional signatures from high throughput data},\n  journal={Scientific Reports},\n  year={2022},\n  month={Dec},\n  day={23},\n  volume={12},\n  number={1},\n  pages={22253},\n  abstract={One of the main objectives of high-throughput genomics studies is to obtain a low-dimensional set of observables---a signature---for sample classification purposes (diagnosis, prognosis, stratification). Biological data, such as gene or protein expression, are commonly characterized by an up/down regulation behavior, for which discriminant-based methods could perform with high accuracy and easy interpretability. To obtain the most out of these methods features selection is even more critical, but it is known to be a NP-hard problem, and thus most feature selection approaches focuses on one feature at the time (k-best, Sequential Feature Selection, recursive feature elimination). We propose DNetPRO, Discriminant Analysis with Network PROcessing, a supervised network-based signature identification method. This method implements a network-based heuristic to generate one or more signatures out of the best performing feature pairs. The algorithm is easily scalable, allowing efficient computing for high number of observables ({\\$}{\\$}10^3{\\$}{\\$}--{\\$}{\\$}10^5{\\$}{\\$}). We show applications on real high-throughput genomic datasets in which our method outperforms existing results, or is compatible with them but with a smaller number of selected features. Moreover, the geometrical simplicity of the resulting class-separation surfaces allows a clearer interpretation of the obtained signatures in comparison to nonlinear classification models.},\n  issn={2045-2322},\n  doi={10.1038/s41598-022-25549-9},\n  url={https://doi.org/10.1038/s41598-022-25549-9}\n}\n```\nor just this repository\n\n```BibTex\n@misc{DNetPRO,\n  author = {Curti, Nico},\n  title = {{DNetPRO pipeline}: Implementation of the DNetPRO pipeline for TCGA datasets},\n  year = {2019},\n  url = {https://github.com/Nico-Curti/DNetPRO},\n  publisher = {GitHub},\n  howpublished = {\\url{https://github.com/Nico-Curti/DNetPRO}}\n}\n```\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fnico-curti%2Fdnetpro","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fnico-curti%2Fdnetpro","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fnico-curti%2Fdnetpro/lists"}