decoupler 1.3.2__tar.gz → 1.9.2__tar.gz

decoupler-1.9.2/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.3
+Name: decoupler
+Version: 1.9.2
+Summary: Ensemble of methods to infer biological activities from omics data
+License: GPL-3.0-only
+Keywords: systems biology,molecular biology,signaling network,transcriptomics,modeling,mechanistic modeling,activity inference,molecular network,omics,biomedicine,molecular footprint,molecular signature
+Author: Pau Badia i Mompel
+Author-email: pau.badia@uni-heidelberg.de
+Requires-Python: >=3.10,<3.12
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Provides-Extra: full
+Requires-Dist: adjusttext (>=1.1.1,<2.0.0) ; extra == "full"
+Requires-Dist: igraph (>=0.11.5,<0.12.0) ; extra == "full"
+Requires-Dist: liana (>=1.5.0,<2.0.0) ; extra == "full"
+Requires-Dist: marsilea (>=0.4.5,<0.5.0) ; extra == "full"
+Requires-Dist: numba (>=0.61.0,<0.62.0)
+Requires-Dist: numpy (>=2,<3)
+Requires-Dist: pandas (>=2.2.2,<3.0.0)
+Requires-Dist: pybiomart (>=0.2.0,<0.3.0) ; extra == "full"
+Requires-Dist: pydeseq2 (>=0.4.0,<0.5.0) ; extra == "full"
+Requires-Dist: scikit-learn (>=1.5.0,<2.0.0) ; extra == "full"
+Requires-Dist: tqdm (>=4.66.4,<5.0.0)
+Requires-Dist: typing-extensions (>=4.12.2,<5.0.0)
+Project-URL: Bug Tracker, https://github.com/saezlab/decoupler-py/issues
+Project-URL: Documentation, https://decoupler.readthedocs.io/
+Project-URL: Homepage, https://decoupler.readthedocs.io/
+Project-URL: Repository, https://github.com/saezlab/decoupler-py
+Description-Content-Type: text/markdown
+
+# decoupler - Ensemble of methods to infer biological activities <img src="https://github.com/saezlab/decoupleR/blob/master/inst/figures/logo.svg?raw=1" align="right" width="120" class="no-scaled-link" />
+<!-- badges: start -->
+[![main](https://github.com/saezlab/decoupler-py/actions/workflows/ci.yml/badge.svg)](https://github.com/saezlab/decoupler-py/actions)
+[![GitHub issues](https://img.shields.io/github/issues/saezlab/decoupler-py.svg)](https://github.com/saezlab/decoupler-py/issues/)
+[![Documentation Status](https://readthedocs.org/projects/decoupler-py/badge/?version=latest)](https://decoupler-py.readthedocs.io/en/latest/?badge=latest)
+[![codecov](https://codecov.io/gh/saezlab/decoupler-py/branch/main/graph/badge.svg?token=TM0P29KKN5)](https://codecov.io/gh/saezlab/decoupler-py)
+[![Downloads](https://static.pepy.tech/badge/decoupler)](https://pepy.tech/project/decoupler)
+
+[![Conda Recipe](https://img.shields.io/badge/recipe-decoupler--py-green.svg)](https://anaconda.org/conda-forge/decoupler-py)
+[![Conda page](https://img.shields.io/conda/vn/conda-forge/decoupler-py.svg)](https://anaconda.org/conda-forge/decoupler-py)
+[![Conda downloads](https://img.shields.io/conda/dn/conda-forge/decoupler-py.svg)](https://anaconda.org/conda-forge/decoupler-py)
+<!-- badges: end -->
+
+`decoupler` is a package containing different enrichment statistical methods to extract biologically driven scores from omics data within a unified framework.
+This is its faster and memory efficient Python implementation, for the R version go [here](https://github.com/saezlab/decoupleR).
+
+For further information and example tutorials, please check our [documentation](https://decoupler-py.readthedocs.io/en/latest/index.html).
+
+If you have any question or problem do not hesitate to open an [issue](https://github.com/saezlab/decoupler-py/issues).
+
+## Installation
+
+`decoupler` can be installed from `pip` (lightweight installation)::
+```
+pip install decoupler
+```
+
+It can also be installed from `conda` and `mamba` (this includes extra dependencies):
+```
+mamba create -n=decoupler conda-forge::decoupler-py
+```
+
+Alternatively, to stay up-to-date with the newest unreleased version, install from source: 
+```
+pip install git+https://github.com/saezlab/decoupler-py.git
+```
+
+## scverse
+`decoupler` is part of the [scverse](https://scverse.org) ecosystem, a collection of tools for single-cell omics data analysis in python.
+For more information check the link.
+
+## License
+Enrichment methods inside decoupler can be used for academic or commercial purposes, except `viper` which holds a non-commercial license. 
+
+The data redistributed by OmniPath does not have a single license, each original resource has its own. By default, `decoupler`
+assumes an academic license, but commercial or nonprofit licenses can be specified in the `license` parameter of `decoupler`'s OmniPath functions.
+[Here](https://omnipathdb.org/info) one can find the license information of all the resources in OmniPath.
+
+## Citation
+
+Badia-i-Mompel P., Vélez Santiago J., Braunger J., Geiss C., Dimitrov D.,
+Müller-Dott S., Taus P., Dugourd A., Holland C.H., Ramirez Flores R.O.
+and Saez-Rodriguez J. 2022. decoupleR: Ensemble of computational methods
+to infer biological activities from omics data. Bioinformatics Advances.
+<https://doi.org/10.1093/bioadv/vbac016>
+

decoupler-1.3.2/PKG-INFO → decoupler-1.9.2/README.md

@@ -1,27 +1,17 @@
-Metadata-Version: 2.1
-Name: decoupler
-Version: 1.3.2
-Summary: Ensemble of methods to infer biological activities from omics data
-Home-page: https://github.com/saezlab/decoupler-py
-Author: Pau Badia i Mompel
-Author-email: pau.badia@uni-heidelberg.de
-Project-URL: Bug Tracker, https://github.com/saezlab/decoupler-py/issues
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
 # decoupler - Ensemble of methods to infer biological activities <img src="https://github.com/saezlab/decoupleR/blob/master/inst/figures/logo.svg?raw=1" align="right" width="120" class="no-scaled-link" />
 <!-- badges: start -->
-[![main](https://github.com/saezlab/decoupler-py/actions/workflows/main.yml/badge.svg)](https://github.com/saezlab/decoupler-py/actions)
+[![main](https://github.com/saezlab/decoupler-py/actions/workflows/ci.yml/badge.svg)](https://github.com/saezlab/decoupler-py/actions)
 [![GitHub issues](https://img.shields.io/github/issues/saezlab/decoupler-py.svg)](https://github.com/saezlab/decoupler-py/issues/)
-[![Downloads](https://pepy.tech/badge/decoupler)](https://pepy.tech/project/decoupler)
 [![Documentation Status](https://readthedocs.org/projects/decoupler-py/badge/?version=latest)](https://decoupler-py.readthedocs.io/en/latest/?badge=latest)
 [![codecov](https://codecov.io/gh/saezlab/decoupler-py/branch/main/graph/badge.svg?token=TM0P29KKN5)](https://codecov.io/gh/saezlab/decoupler-py)
+[![Downloads](https://static.pepy.tech/badge/decoupler)](https://pepy.tech/project/decoupler)
+
+[![Conda Recipe](https://img.shields.io/badge/recipe-decoupler--py-green.svg)](https://anaconda.org/conda-forge/decoupler-py)
+[![Conda page](https://img.shields.io/conda/vn/conda-forge/decoupler-py.svg)](https://anaconda.org/conda-forge/decoupler-py)
+[![Conda downloads](https://img.shields.io/conda/dn/conda-forge/decoupler-py.svg)](https://anaconda.org/conda-forge/decoupler-py)
 <!-- badges: end -->
 
-**decoupler** is a package containing different statistical methods to extract biological activities from omics data within a unified framework.
+`decoupler` is a package containing different enrichment statistical methods to extract biologically driven scores from omics data within a unified framework.
 This is its faster and memory efficient Python implementation, for the R version go [here](https://github.com/saezlab/decoupleR).
 
 For further information and example tutorials, please check our [documentation](https://decoupler-py.readthedocs.io/en/latest/index.html).
@@ -30,24 +20,30 @@ If you have any question or problem do not hesitate to open an [issue](https://g
 
 ## Installation
 
-To install the latest stable version run:
+`decoupler` can be installed from `pip` (lightweight installation)::
 ```
 pip install decoupler
 ```
 
-Alternatively, to stay up-to-date with the newest version, run: 
+It can also be installed from `conda` and `mamba` (this includes extra dependencies):
+```
+mamba create -n=decoupler conda-forge::decoupler-py
+```
+
+Alternatively, to stay up-to-date with the newest unreleased version, install from source: 
 ```
 pip install git+https://github.com/saezlab/decoupler-py.git
 ```
 
 ## scverse
-**decoupler** is part of the [scverse](https://scverse.org) ecosystem, a collection of tools for single-cell omics data analysis in python.
+`decoupler` is part of the [scverse](https://scverse.org) ecosystem, a collection of tools for single-cell omics data analysis in python.
 For more information check the link.
 
 ## License
-Footprint methods inside decoupler can be used for academic or commercial purposes, except `viper` which holds a non-commercial license. 
+Enrichment methods inside decoupler can be used for academic or commercial purposes, except `viper` which holds a non-commercial license. 
 
-The data redistributed by OmniPath does not have a license, each original resource carries their own. 
+The data redistributed by OmniPath does not have a single license, each original resource has its own. By default, `decoupler`
+assumes an academic license, but commercial or nonprofit licenses can be specified in the `license` parameter of `decoupler`'s OmniPath functions.
 [Here](https://omnipathdb.org/info) one can find the license information of all the resources in OmniPath.
 
 ## Citation

decoupler-1.9.2/decoupler/__init__.py

@@ -0,0 +1,39 @@
+__version__ = '1.9.2'  # noqa: F401
+__version_info__ = tuple([int(num) for num in __version__.split('.')])  # noqa: F401
+
+from .pre import extract, match, rename_net, get_net_mat, filt_min_n, mask_features, return_data, break_ties  # noqa: F401
+from .utils import (
+    melt, show_methods, check_corr, get_toy_data, summarize_acts, assign_groups, dense_run, p_adjust_fdr, shuffle_net,
+    read_gmt  # noqa: F401
+)
+from .utils_anndata import (
+    get_acts, swap_layer, get_pseudobulk, get_contrast, rank_sources_groups, get_top_targets, format_contrast_results,
+    filter_by_expr, filter_by_prop, get_metadata_associations  # noqa: F401
+)
+from .method_wmean import run_wmean  # noqa: F401
+from .method_wsum import run_wsum  # noqa: F401
+from .method_ulm import run_ulm  # noqa: F401
+from .method_mdt import run_mdt  # noqa: F401
+from .method_mlm import run_mlm  # noqa: F401
+from .method_udt import run_udt  # noqa: F401
+from .method_ora import run_ora, test1r, get_ora_df  # noqa: F401
+from .method_gsva import run_gsva  # noqa: F401
+from .method_gsea import run_gsea, get_gsea_df  # noqa: F401
+from .method_viper import run_viper  # noqa: F401
+from .method_aucell import run_aucell  # noqa: F401
+from .method_zscore import run_zscore  # noqa: F401
+from .decouple import decouple, run_consensus  # noqa: F401
+from .consensus import cons  # noqa: F401
+from .omnip import (
+    show_resources, get_resource, get_progeny, get_dorothea, translate_net, get_collectri, get_ksn_omnipath, show_organisms  # noqa: F401
+)
+from .plotting import (
+    plot_volcano, plot_violins, plot_barplot, plot_metrics_scatter, plot_metrics_boxplot, plot_metrics_scatter_cols,
+    plot_psbulk_samples, plot_filter_by_expr, plot_filter_by_prop, plot_volcano_df, plot_targets, plot_running_score,
+    plot_dotplot, plot_barplot_df, plot_associations, plot_network  # noqa: F401
+)
+from .benchmark import benchmark, format_benchmark_inputs, get_performances  # noqa: F401
+from .utils_benchmark import get_toy_benchmark_data, show_metrics  # noqa: F401
+from .metrics import (
+    metric_auroc, metric_auprc, metric_mcauroc, metric_mcauprc, metric_rank, metric_nrank, metric_recall  # noqa: F401
+)

{decoupler-1.3.2 → decoupler-1.9.2}/decoupler/benchmark.py

@@ -9,15 +9,15 @@ import pandas as pd
 from .decouple import decouple
 from .utils_anndata import extract_psbulk_inputs
 from .pre import rename_net, filt_min_n
-from .utils_benchmark import format_acts_grts, append_metrics_scores
+from .utils_benchmark import format_acts_grts, append_metrics_scores, adjust_sign
 from .utils_benchmark import validate_metrics, check_groupby, rename_obs
 
 
-def get_performances(res, obs, groupby, by, metrics, min_exp=5, pi0=0.5, n_iter=1000,
-                     seed=42, verbose=False):
+def get_performances(res, obs, groupby, by, metrics, use_pval=None, min_exp=5, pi0=0.5,
+                     n_iter=1000, seed=42, verbose=False):
 
     # Return acts, grts and msks tensors
-    acts, grts, msks, srcs, mthds, grpbys, grps = format_acts_grts(res, obs, groupby)
+    acts, grts, msks, srcs, mthds, grpbys, grps = format_acts_grts(res, obs, groupby, use_pval)
 
     # Init empty df
     df = []
@@ -90,30 +90,36 @@ def format_benchmark_inputs(mat, obs, perturb, sign, net, groupby, by, f_expr=Tr
         srcs = net['source'].values.astype('U')
         for i, src in enumerate(obs['perturb']):
             msk[i] = np.any(np.isin(src, srcs))
-        if verbose:
-            n = np.sum(~msk)
-            print("{0} experiments without sources in net, they will be removed.".format(n))
         mat, obs = mat[msk], obs.loc[msk]
+        if verbose:
+            n_removed = np.sum(~msk)
+            print("Removed {0} experiments without sources in net.".format(n_removed))
 
     # Remove sources without experiments in obs
     if f_srcs:
-        msk = np.isin(net['source'].values, obs['perturb'].values.ravel())
-        if verbose:
-            n = np.sum(~msk)
-            print("{0} sources without experiments in obs, they will be removed.".format(n))
+        srcs = net.loc[:, 'source'].values
+        msk = np.isin(srcs, obs['perturb'].values.ravel())
         net = net.loc[msk]
+        if verbose:
+            n_removed = np.unique(srcs[~msk]).size
+            print("Removed {0} sources without experiments in obs.".format(n_removed))
 
     return mat, obs, var, net, groupby
 
 
 def _benchmark(mat, obs, net, perturb, sign, metrics=['auroc', 'auprc'], groupby=None, by='experiment', f_expr=True,
-               f_srcs=False, min_exp=5, pi0=0.5, n_iter=1000, seed=42, verbose=True, use_raw=True, decouple_kws={}):
+               f_srcs=False, use_pval=None, min_exp=5, pi0=0.5, n_iter=1000, seed=42, verbose=True, use_raw=True,
+               decouple_kws={}):
 
     # Format inputs
     mat, obs, var, net, groupby = format_benchmark_inputs(mat, obs, perturb, sign, net, groupby, by, f_expr=f_expr,
                                                           f_srcs=f_srcs, verbose=verbose, use_raw=use_raw,
                                                           decouple_kws=decouple_kws)
 
+    # Adjust sign
+    mat = adjust_sign(mat, obs['sign'].values)
+    obs['sign'] = 1
+
     # Reset net names args
     decouple_kws['source'] = 'source'
     decouple_kws['target'] = 'target'
@@ -121,23 +127,31 @@ def _benchmark(mat, obs, net, perturb, sign, metrics=['auroc', 'auprc'], groupby
 
     # Run prediction
     if verbose:
+        srcs = []
+        for p in obs.loc[:, 'perturb']:
+            if isinstance(p, list):
+                srcs.extend(p)
+            else:
+                srcs.append(p)
+        n_src = np.unique(srcs).size
+        print("Running {0} experiments for {1} unique sources.".format(mat.shape[0], n_src))
         print('Running methods...')
     res = decouple([mat, obs.index, var.index], net, verbose=verbose, **decouple_kws)
 
     # Compute metrics
     if verbose:
         print('Calculating metrics...')
-    df = get_performances(res, obs, groupby, by, metrics, min_exp=min_exp, pi0=pi0,
-                          n_iter=n_iter, seed=seed, verbose=verbose)
+    df = get_performances(res, obs, groupby, by, metrics, use_pval=use_pval, min_exp=min_exp,
+                          pi0=pi0, n_iter=n_iter, seed=seed, verbose=verbose)
     if verbose:
         print('Done.')
 
     return df
 
 
-def benchmark(mat, obs, net, perturb, sign, metrics=['auroc', 'auprc', 'mcauroc', 'mcauprc'], groupby=None,
-              by='experiment', f_expr=True, f_srcs=False, min_exp=5, pi0=0.5, n_iter=1000, seed=42,
-              verbose=True, use_raw=True, decouple_kws={}):
+def benchmark(mat, obs, net, perturb, sign, metrics=['auroc', 'auprc', 'mcauroc', 'mcauprc', 'rank', 'nrank', 'recall'],
+              groupby=None, by='experiment', f_expr=True, f_srcs=False, use_pval=None, min_exp=5, pi0=0.5, n_iter=1000,
+              seed=42, verbose=True, use_raw=True, decouple_kws={}):
     """
     Benchmark methods or networks on a given set of perturbation experiments using activity inference with decoupler.
 
@@ -156,8 +170,7 @@ def benchmark(mat, obs, net, perturb, sign, metrics=['auroc', 'auprc', 'mcauroc'
         Column name in obs with sign of the perturbation. Can be set to 1 or -1 if all experiments are overexpression or
         knockouts, respectively.
     metrics : list, str
-        Performance metric(s) to compute. See the description of get_performance for more details. Defaults
-        to ['roc', 'calprc'].
+        Performance metric(s) to compute. See the description of get_performance for more details.
     groupby : list, str, None
         Performance metrics(s) can be computed per groups if enough experiments are available.
     by : str
@@ -166,6 +179,9 @@ def benchmark(mat, obs, net, perturb, sign, metrics=['auroc', 'auprc', 'mcauroc'
         Whether to filter out experiments whose perturbed sources are not in the given net. Defaults to True.
     f_srcs : bool
         Whether to fitler out sources in net for which there are not perturbation data. Defaults to False.
+    use_pval: None, float
+        Whether to fitler out activity scores by a given p-value after FDR correction (BH). Defaults to None. Methods that
+        generate no p-value will use the (1 - pvalue) quantile based on activity score as being significant.
     min_exp : int
         Minimum of perturbation experiments per group.
     pi0 : float
@@ -211,8 +227,8 @@ def benchmark(mat, obs, net, perturb, sign, metrics=['auroc', 'auprc', 'mcauroc'
         decouple_kws = {**default_kws, **decouple_kws}
 
         # Run benchmark
-        df = _benchmark(mat, obs, net, perturb, sign, metrics, groupby, by, f_expr, f_srcs, min_exp, pi0,
-                        n_iter, seed, verbose, use_raw, decouple_kws)
+        df = _benchmark(mat, obs, net, perturb, sign, metrics, groupby, by, f_expr, f_srcs, use_pval, min_exp,
+                        pi0, n_iter, seed, verbose, use_raw, decouple_kws)
     else:
         df = []
         for net_name in net:
@@ -226,7 +242,7 @@ def benchmark(mat, obs, net, perturb, sign, metrics=['auroc', 'auprc', 'mcauroc'
 
             # Run benchmark
             tmp = _benchmark(mat, obs, net[net_name], perturb, sign, metrics, groupby, by, f_expr, f_srcs,
-                             min_exp, pi0, n_iter, seed, verbose, use_raw, decouple_kws[net_name])
+                             use_pval, min_exp, pi0, n_iter, seed, verbose, use_raw, decouple_kws[net_name])
             tmp['net'] = net_name
             df.append(tmp)
 

{decoupler-1.3.2 → decoupler-1.9.2}/decoupler/decouple.py

@@ -5,7 +5,7 @@ Code to run methods simultaneously.
 
 import decoupler as dc
 from anndata import AnnData
-
+from .utils import show_methods, dense_run
 from .consensus import cons
 from .pre import extract
 
@@ -21,7 +21,7 @@ def get_wrappers(methods):
     return tmp
 
 
-def run_methods(mat, net, source, target, weight, methods, args, min_n, verbose, use_raw):
+def run_methods(mat, net, source, target, weight, methods, args, min_n, verbose, use_raw, dense):
 
     # Retrieve wrapper functions
     wrappers = get_wrappers(methods)
@@ -45,10 +45,20 @@ def run_methods(mat, net, source, target, weight, methods, args, min_n, verbose,
         is_weighted = 'weight' in f.__code__.co_varnames
 
         # Run method
-        if is_weighted:
+        if is_weighted and not dense:
             res = f(mat=mat, net=net, source=source, target=target, weight=weight, **a)
-        else:
+        elif not is_weighted and not dense:
             res = f(mat=mat, net=net, source=source, target=target, **a)
+        else:
+            res = dense_run(
+                func=f,
+                mat=mat,
+                net=net,
+                source=source,
+                target=target,
+                weight=weight,
+                **a
+            )
 
         # Extract for AnnData
         if res is None:
@@ -78,7 +88,7 @@ def parse_methods(methods, cns_metds):
             cns_metds = ['mlm_estimate', 'ulm_estimate', 'wsum_norm']
     elif not isinstance(methods, list):
         if methods.lower() == 'all':
-            methods = [method.split('run_')[1] for method in dc.show_methods()['Function'] if method != 'run_consensus']
+            methods = [method.split('run_')[1] for method in show_methods()['Function'] if method != 'run_consensus']
         else:
             methods = [methods]
 
@@ -86,7 +96,7 @@ def parse_methods(methods, cns_metds):
 
 
 def decouple(mat, net, source='source', target='target', weight='weight', methods=None, args={}, consensus=True,
-             cns_metds=None, min_n=5, verbose=True, use_raw=True):
+             cns_metds=None, min_n=5, verbose=True, use_raw=True, dense=False):
     """
     Decouple function.
 
@@ -120,6 +130,8 @@ def decouple(mat, net, source='source', target='target', weight='weight', method
         Whether to show progress.
     use_raw : bool
         If mat is AnnData, use its raw attribute.
+    dense : bool
+        Whether to run methods ignoring zero values per observation. See ``decoupler.dense_run`` for more information.
 
     Returns
     -------
@@ -138,7 +150,7 @@ def decouple(mat, net, source='source', target='target', weight='weight', method
                 print('Method name {0} in args not found in methods, will be ignored.'.format(methd))
 
     # Run methods
-    results = run_methods(mat, net, source, target, weight, methods, args, min_n, verbose, use_raw)
+    results = run_methods(mat, net, source, target, weight, methods, args, min_n, verbose, use_raw, dense)
 
     # Run consensus score
     if consensus:
@@ -161,7 +173,7 @@ def decouple(mat, net, source='source', target='target', weight='weight', method
         return results
 
 
-def run_consensus(mat, net, source='source', target='target', weight='weight', min_n=5, verbose=False, use_raw=True):
+def run_consensus(mat, net, source='source', target='target', weight='weight', min_n=5, verbose=False, use_raw=True, args={}):
     """
     Consensus score from top methods.
 
@@ -192,6 +204,8 @@ def run_consensus(mat, net, source='source', target='target', weight='weight', m
         Whether to show progress.
     use_raw : bool
         Use raw attribute of mat if present.
+    args : dict
+        Parameters for the ``decoupler.decouple`` function.
 
     Returns
     -------
@@ -209,7 +223,7 @@ def run_consensus(mat, net, source='source', target='target', weight='weight', m
 
     # Run top methods
     res = decouple(mat=[m, r, c], net=net, source=source, target=target, weight=weight,
-                   min_n=min_n, verbose=verbose, use_raw=use_raw)
+                   min_n=min_n, verbose=verbose, use_raw=use_raw, args=args)
 
     # Exctract
     estimate, pvals = res['consensus_estimate'], res['consensus_pvals']

{decoupler-1.3.2 → decoupler-1.9.2}/decoupler/method_aucell.py

@@ -5,75 +5,75 @@ Code to run the AUCell method.
 
 import numpy as np
 import pandas as pd
+from scipy.sparse import csr_matrix
 
-from numpy.random import default_rng
+from tqdm.auto import tqdm
 
-from .pre import extract, rename_net, filt_min_n
+from .pre import extract, rename_net, filt_min_n, return_data, break_ties
 
-from anndata import AnnData
 import numba as nb
 
 
-@nb.njit(nb.f4[:, :](nb.i8, nb.i8, nb.f4[:], nb.i8[:], nb.i8[:], nb.i8[:], nb.i8[:], nb.i8), parallel=True, cache=True)
-def nb_aucell(n_samples, n_features, data, indptr, indices, net, offsets, n_up):
+@nb.njit(nb.f4[:](nb.f4[:], nb.i8[:], nb.i8[:], nb.i8[:], nb.i8, nb.i8), parallel=True, cache=True)
+def nb_aucell(row, net, starts, offsets, n_up, n_fsets):
 
-    # Number of feature sets
-    n_fsets = offsets.shape[0]
-
-    # Define starts to subset offsets
-    starts = np.zeros(n_fsets, dtype=nb.i8)
-    starts[1:] = np.cumsum(offsets)[:-1]
+    # Rank row
+    row = np.argsort(np.argsort(-row)) + 1
 
     # Empty acts
-    acts = np.zeros((n_samples, n_fsets), dtype=nb.f4)
+    es = np.zeros(n_fsets, dtype=nb.f4)
 
-    # For each sample
-    for i in nb.prange(n_samples):
+    # For each feature set
+    for j in nb.prange(n_fsets):
 
-        # Extract sample from sparse matrix
-        row = np.zeros(n_features, dtype=nb.f4)
-        s, e = indptr[i], indptr[i+1]
-        row[indices[s:e]] = data[s:e]
+        # Extract feature set
+        srt = starts[j]
+        off = offsets[j] + srt
+        fset = net[srt:off]
 
-        # Rank row
-        row = np.argsort(np.argsort(-row)) + 1
+        # Compute max AUC for fset
+        x_th = np.arange(1, stop=fset.shape[0]+1, dtype=nb.i8)
+        x_th = x_th[x_th < n_up]
+        max_auc = np.sum(np.diff(np.append(x_th, n_up)) * x_th)
 
-        # For each feature set
-        for j in range(n_fsets):
+        # Compute AUC
+        x = row[fset]
+        x = np.sort(x[x < n_up])
+        y = np.arange(x.shape[0]) + 1
+        x = np.append(x, n_up)
 
-            # Extract feature set
-            srt = starts[j]
-            off = offsets[j] + srt
-            fset = net[srt:off]
+        # Update acts matrix
+        es[j] = np.sum(np.diff(x) * y) / max_auc
 
-            # Compute max AUC for fset
-            x_th = np.arange(start=1, stop=fset.shape[0]+1, dtype=nb.i8)
-            x_th = x_th[x_th < n_up]
-            max_auc = np.sum(np.diff(np.append(x_th, n_up)) * x_th)
+    return es
 
-            # Compute AUC
-            x = row[fset]
-            x = np.sort(x[x < n_up])
-            y = np.arange(x.shape[0]) + 1
-            x = np.append(x, n_up)
 
-            # Update acts matrix
-            acts[i, j] = np.sum(np.diff(x) * y)/max_auc
+def aucell(mat, net, n_up, verbose):
 
-    return acts
-
-
-def aucell(mat, net, n_up):
+    # Get dims
+    n_samples = mat.shape[0]
+    n_fsets = net.shape[0]
 
     # Flatten net and get offsets
     offsets = net.apply(lambda x: len(x)).values.astype(np.int64)
     net = np.concatenate(net.values)
 
-    # Compute AUC per fset
-    acts = nb_aucell(mat.shape[0], mat.shape[1], mat.data, mat.indptr.astype(np.int64),
-                     mat.indices.astype(np.int64), net, offsets, n_up)
+    # Define starts to subset offsets
+    starts = np.zeros(n_fsets, dtype=np.int64)
+    starts[1:] = np.cumsum(offsets)[:-1]
+
+    es = np.zeros((n_samples, n_fsets), dtype=np.float32)
+    for i in tqdm(range(mat.shape[0]), disable=not verbose):
+
+        if isinstance(mat, csr_matrix):
+            row = mat[i].toarray()[0]
+        else:
+            row = mat[i]
 
-    return acts
+        # Compute AUC per row
+        es[i] = nb_aucell(row, net, starts, offsets, n_up, n_fsets)
+
+    return es
 
 
 def run_aucell(mat, net, source='source', target='target', n_up=None, min_n=5, seed=42, verbose=False, use_raw=True):
@@ -119,9 +119,10 @@ def run_aucell(mat, net, source='source', target='target', n_up=None, min_n=5, s
 
     # Set n_up
     if n_up is None:
-        n_up = np.ceil(0.05*len(c))
+        n_up = int(np.ceil(0.05*len(c)))
     else:
-        n_up = np.ceil(n_up)
+        n_up = int(np.ceil(n_up))
+        n_up = np.min([n_up, c.size])  # Limit n_up to max features
     if not 0 < n_up:
         raise ValueError('n_up needs to be a value higher than 0.')
 
@@ -130,27 +131,19 @@ def run_aucell(mat, net, source='source', target='target', n_up=None, min_n=5, s
     net = filt_min_n(c, net, min_n=min_n)
 
     # Randomize feature order to break ties randomly
-    rng = default_rng(seed=seed)
-    idx = np.arange(m.shape[1])
-    rng.shuffle(idx)
-    m, c = m[:, idx], c[idx]
+    m, c = break_ties(m, c, seed)
 
     # Transform targets to indxs
     table = {name: i for i, name in enumerate(c)}
     net['target'] = [table[target] for target in net['target']]
-    net = net.groupby('source')['target'].apply(lambda x: np.array(x, dtype=np.int64))
+    net = net.groupby('source', observed=True)['target'].apply(lambda x: np.array(x, dtype=np.int64))
 
     if verbose:
         print('Running aucell on mat with {0} samples and {1} targets for {2} sources.'.format(m.shape[0], len(c), len(net)))
 
     # Run AUCell
-    estimate = aucell(m, net, n_up)
+    estimate = aucell(m, net, n_up, verbose)
     estimate = pd.DataFrame(estimate, index=r, columns=net.index)
     estimate.name = 'aucell_estimate'
 
-    # AnnData support
-    if isinstance(mat, AnnData):
-        # Update obsm AnnData object
-        mat.obsm[estimate.name] = estimate
-    else:
-        return estimate
+    return return_data(mat=mat, results=(estimate, ))