From 46a506f1404584483fa3110f77a72658ec4bb0af Mon Sep 17 00:00:00 2001 From: ilibarra Date: Tue, 30 Mar 2021 21:11:03 +0200 Subject: [PATCH 1/7] add simplified template for rp_simple --- .../methods/beta.py | 19 ++- .../methods/maestro.py | 61 +++++++++ .../tests/snare_chrompotential_maestro.ipynb | 116 ++++++++++++++++++ 3 files changed, 192 insertions(+), 4 deletions(-) create mode 100644 openproblems/tasks/regulatory_effect_prediction/methods/maestro.py create mode 100644 openproblems/tasks/regulatory_effect_prediction/tests/snare_chrompotential_maestro.ipynb diff --git a/openproblems/tasks/regulatory_effect_prediction/methods/beta.py b/openproblems/tasks/regulatory_effect_prediction/methods/beta.py index cc348e6002..0ec872bc9b 100644 --- a/openproblems/tasks/regulatory_effect_prediction/methods/beta.py +++ b/openproblems/tasks/regulatory_effect_prediction/methods/beta.py @@ -6,6 +6,7 @@ import scanpy as sc import warnings +from .maestro import _rp_simple def _chrom_limit(x, tss_size=2e5): """Extend TSS to upstream and downstream intervals. @@ -51,7 +52,7 @@ def _get_annotation(adata, retries=3): try: with warnings.catch_warnings(): warnings.filterwarnings( - action="ignore", message="No results found for query" + action="ignore", message="" ) gene = data.gene_by_id(i) genes.append( @@ -66,7 +67,7 @@ def _get_annotation(adata, retries=3): try: with warnings.catch_warnings(): warnings.filterwarnings( - action="ignore", message="No results found for query" + action="ignore", message="" ) i = data.gene_ids_of_gene_name(i)[0] gene = data.gene_by_id(i) @@ -79,7 +80,7 @@ def _get_annotation(adata, retries=3): ] ) except (IndexError, ValueError) as e: - print(e) + # print(e) genes.append([np.nan, np.nan, np.nan, np.nan]) old_col = adata.var.columns.values adata.var = pd.concat( @@ -135,6 +136,9 @@ def _filter_has_chr(adata): return adata + + + def _atac_genes_score(adata, top_genes=2000, threshold=1, method="beta"): """Calculate gene scores and insert into .obsm.""" import pybedtools @@ -211,21 +215,26 @@ def _atac_genes_score(adata, top_genes=2000, threshold=1, method="beta"): ) # overlap TSS bins with peaks + x = pybedtools.BedTool.from_dataframe(summits) y = pybedtools.BedTool.from_dataframe(extend_tss) + tss_to_peaks = x.intersect(y, wb=True, wa=True, loj=True).to_dataframe() # remove non-overlapped TSS and peaks tss_to_peaks = tss_to_peaks.loc[ (tss_to_peaks.thickEnd != ".") | (tss_to_peaks.score != "."), : ] - + if method == "beta": _beta(tss_to_peaks, adata, threshold) elif method == "archr_model21": _archr_model21(tss_to_peaks, adata) elif method == "marge": _marge(tss_to_peaks, adata) + elif method == "rp_simple": + _rp_simple(tss_to_peaks, adata) + return adata @@ -329,3 +338,5 @@ def marge(adata, n_top_genes=500): def archr_model21(adata, n_top_genes=500): adata = _atac_genes_score(adata, top_genes=n_top_genes, method="archr_model21") return adata + + diff --git a/openproblems/tasks/regulatory_effect_prediction/methods/maestro.py b/openproblems/tasks/regulatory_effect_prediction/methods/maestro.py new file mode 100644 index 0000000000..cd8b52527f --- /dev/null +++ b/openproblems/tasks/regulatory_effect_prediction/methods/maestro.py @@ -0,0 +1,61 @@ +from ....tools.decorators import method + +def _rp_simple(tss_to_peaks, adata): + import scipy + import numpy as np + # the coordinates of the current peaks + peaks = adata.uns['mode2_var'] + + decay = 10000 + + Sg = lambda x: 2**(-x) + gene_distance = 15 * decay + + weights = [] + for ri, r in tss_to_peaks.iterrows(): + wi = 0 + summit_chr, tss_summit_start, tss_summit_end = r[:3] + tss_extend_chr, tss_extend_start, tss_extend_end = r[4:7] + + # print(summit_chr, summit_start, summit_end, extend_chr, extend_start, extend_end) + sel_chr = [pi for pi in peaks if pi[0] == tss_extend_chr] + sel_peaks = [pi for pi in sel_chr if int(pi[1]) >= tss_extend_start and int(pi[2]) <= tss_extend_end] + + # print('# peaks in chromosome', len(sel_chr), '# of peaks around tss', len(sel_peaks)) + # if len(sel_peaks) > 0: + # print(sel_peaks) + + # if peaks then this is take them into account, one by one + for pi in sel_peaks: + summit_peak = int((int(pi[2]) + int(pi[1])) / 2) + distance = np.abs(tss_summit_start - summit_peak) + # print(pi, distance, Sg(distance / decay)) + wi += Sg(distance / decay) + + weights.append(wi) + + tss_to_peaks['weight'] = weights + + gene_peak_weight = scipy.sparse.csr_matrix( + ( + tss_to_peaks.weight.values, + (tss_to_peaks.thickEnd.astype("int32").values, tss_to_peaks.name.values), + ), + shape=(adata.shape[1], adata.uns["mode2_var"].shape[0]), + ) + + adata.obsm["gene_score"] = adata.obsm["mode2"] @ gene_peak_weight.T + +@method( + method_name="RP_simple", + paper_name="""Integrative analyses of single-cell transcriptome and regulome using MAESTRO.""", + paper_url="https://genomebiology.biomedcentral.com/articles/10.1186/s13059-020-02116-x", + paper_year=2020, + code_version="1.0", + code_url="https://github.com/liulab-dfci/MAESTRO", + image="openproblems-python-extras", +) +def rp_simple(adata, n_top_genes=500): + from .beta import _atac_genes_score + adata = _atac_genes_score(adata, top_genes=n_top_genes, method="rp_simple") + return adata diff --git a/openproblems/tasks/regulatory_effect_prediction/tests/snare_chrompotential_maestro.ipynb b/openproblems/tasks/regulatory_effect_prediction/tests/snare_chrompotential_maestro.ipynb new file mode 100644 index 0000000000..2b616a922f --- /dev/null +++ b/openproblems/tasks/regulatory_effect_prediction/tests/snare_chrompotential_maestro.ipynb @@ -0,0 +1,116 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "from openproblems.tasks.regulatory_effect_prediction import datasets, methods\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "adata = datasets.snare_p0_braincortex(test=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "adata = methods.rp_simple(adata, n_top_genes=2000)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "adata.obsm" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%autoreload 2\n", + "\n", + "import seaborn as sns\n", + "from openproblems.tasks.regulatory_effect_prediction import metrics\n", + "cors = metrics.spearman_correlation(adata)\n", + "print(cors)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%autoreload 2\n", + "\n", + "from openproblems.tasks.regulatory_effect_prediction import metrics\n", + "import seaborn as sns\n", + "cors = metrics.pearson_correlation(adata)\n", + "\n", + "print(cors)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "openproblems", + "language": "python", + "name": "openproblems" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.10" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 2e3549631d3c79feaa60dd1a95a80293584dbcb3 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Tue, 30 Mar 2021 19:19:08 +0000 Subject: [PATCH 2/7] pre-commit --- .../methods/beta.py | 21 ++++++------------- .../methods/maestro.py | 20 ++++++++++++------ 2 files changed, 20 insertions(+), 21 deletions(-) diff --git a/openproblems/tasks/regulatory_effect_prediction/methods/beta.py b/openproblems/tasks/regulatory_effect_prediction/methods/beta.py index 0ec872bc9b..b44b28f633 100644 --- a/openproblems/tasks/regulatory_effect_prediction/methods/beta.py +++ b/openproblems/tasks/regulatory_effect_prediction/methods/beta.py @@ -1,12 +1,12 @@ from ....patch import patch_datacache from ....tools.decorators import method +from .maestro import _rp_simple import numpy as np import pandas as pd import scanpy as sc import warnings -from .maestro import _rp_simple def _chrom_limit(x, tss_size=2e5): """Extend TSS to upstream and downstream intervals. @@ -51,9 +51,7 @@ def _get_annotation(adata, retries=3): for i in adata.var.index.map(lambda x: x.split(".")[0]): try: with warnings.catch_warnings(): - warnings.filterwarnings( - action="ignore", message="" - ) + warnings.filterwarnings(action="ignore", message="") gene = data.gene_by_id(i) genes.append( [ @@ -66,9 +64,7 @@ def _get_annotation(adata, retries=3): except ValueError: try: with warnings.catch_warnings(): - warnings.filterwarnings( - action="ignore", message="" - ) + warnings.filterwarnings(action="ignore", message="") i = data.gene_ids_of_gene_name(i)[0] gene = data.gene_by_id(i) genes.append( @@ -136,9 +132,6 @@ def _filter_has_chr(adata): return adata - - - def _atac_genes_score(adata, top_genes=2000, threshold=1, method="beta"): """Calculate gene scores and insert into .obsm.""" import pybedtools @@ -215,17 +208,17 @@ def _atac_genes_score(adata, top_genes=2000, threshold=1, method="beta"): ) # overlap TSS bins with peaks - + x = pybedtools.BedTool.from_dataframe(summits) y = pybedtools.BedTool.from_dataframe(extend_tss) - + tss_to_peaks = x.intersect(y, wb=True, wa=True, loj=True).to_dataframe() # remove non-overlapped TSS and peaks tss_to_peaks = tss_to_peaks.loc[ (tss_to_peaks.thickEnd != ".") | (tss_to_peaks.score != "."), : ] - + if method == "beta": _beta(tss_to_peaks, adata, threshold) elif method == "archr_model21": @@ -338,5 +331,3 @@ def marge(adata, n_top_genes=500): def archr_model21(adata, n_top_genes=500): adata = _atac_genes_score(adata, top_genes=n_top_genes, method="archr_model21") return adata - - diff --git a/openproblems/tasks/regulatory_effect_prediction/methods/maestro.py b/openproblems/tasks/regulatory_effect_prediction/methods/maestro.py index cd8b52527f..54c54b65ba 100644 --- a/openproblems/tasks/regulatory_effect_prediction/methods/maestro.py +++ b/openproblems/tasks/regulatory_effect_prediction/methods/maestro.py @@ -1,14 +1,16 @@ from ....tools.decorators import method + def _rp_simple(tss_to_peaks, adata): - import scipy import numpy as np - # the coordinates of the current peaks - peaks = adata.uns['mode2_var'] + import scipy + + # the coordinates of the current peaks + peaks = adata.uns["mode2_var"] decay = 10000 - Sg = lambda x: 2**(-x) + def Sg(x): return 2 ** (-x) gene_distance = 15 * decay weights = [] @@ -19,7 +21,11 @@ def _rp_simple(tss_to_peaks, adata): # print(summit_chr, summit_start, summit_end, extend_chr, extend_start, extend_end) sel_chr = [pi for pi in peaks if pi[0] == tss_extend_chr] - sel_peaks = [pi for pi in sel_chr if int(pi[1]) >= tss_extend_start and int(pi[2]) <= tss_extend_end] + sel_peaks = [ + pi + for pi in sel_chr + if int(pi[1]) >= tss_extend_start and int(pi[2]) <= tss_extend_end + ] # print('# peaks in chromosome', len(sel_chr), '# of peaks around tss', len(sel_peaks)) # if len(sel_peaks) > 0: @@ -34,7 +40,7 @@ def _rp_simple(tss_to_peaks, adata): weights.append(wi) - tss_to_peaks['weight'] = weights + tss_to_peaks["weight"] = weights gene_peak_weight = scipy.sparse.csr_matrix( ( @@ -46,6 +52,7 @@ def _rp_simple(tss_to_peaks, adata): adata.obsm["gene_score"] = adata.obsm["mode2"] @ gene_peak_weight.T + @method( method_name="RP_simple", paper_name="""Integrative analyses of single-cell transcriptome and regulome using MAESTRO.""", @@ -57,5 +64,6 @@ def _rp_simple(tss_to_peaks, adata): ) def rp_simple(adata, n_top_genes=500): from .beta import _atac_genes_score + adata = _atac_genes_score(adata, top_genes=n_top_genes, method="rp_simple") return adata From 7a18cc68fbf08beaccd81d9e8d0e90ae4590f39a Mon Sep 17 00:00:00 2001 From: ilibarra Date: Wed, 31 Mar 2021 00:10:00 +0200 Subject: [PATCH 3/7] updated to remove flake8 typos --- .../methods/__init__.py | 1 + .../methods/beta.py | 23 ++---- .../methods/maestro.py | 36 ++++++--- .../tests/snare_chrompotential_maestro.ipynb | 76 +++++++++++++++++-- 4 files changed, 101 insertions(+), 35 deletions(-) diff --git a/openproblems/tasks/regulatory_effect_prediction/methods/__init__.py b/openproblems/tasks/regulatory_effect_prediction/methods/__init__.py index 37894113cd..c050b84190 100644 --- a/openproblems/tasks/regulatory_effect_prediction/methods/__init__.py +++ b/openproblems/tasks/regulatory_effect_prediction/methods/__init__.py @@ -1,3 +1,4 @@ from .beta import archr_model21 from .beta import beta from .beta import marge +from .maestro import rp_simple diff --git a/openproblems/tasks/regulatory_effect_prediction/methods/beta.py b/openproblems/tasks/regulatory_effect_prediction/methods/beta.py index 0ec872bc9b..23deac1749 100644 --- a/openproblems/tasks/regulatory_effect_prediction/methods/beta.py +++ b/openproblems/tasks/regulatory_effect_prediction/methods/beta.py @@ -1,12 +1,12 @@ from ....patch import patch_datacache from ....tools.decorators import method +from .maestro import _rp_simple import numpy as np import pandas as pd import scanpy as sc import warnings -from .maestro import _rp_simple def _chrom_limit(x, tss_size=2e5): """Extend TSS to upstream and downstream intervals. @@ -51,9 +51,7 @@ def _get_annotation(adata, retries=3): for i in adata.var.index.map(lambda x: x.split(".")[0]): try: with warnings.catch_warnings(): - warnings.filterwarnings( - action="ignore", message="" - ) + warnings.filterwarnings(action="ignore", message="") gene = data.gene_by_id(i) genes.append( [ @@ -66,9 +64,7 @@ def _get_annotation(adata, retries=3): except ValueError: try: with warnings.catch_warnings(): - warnings.filterwarnings( - action="ignore", message="" - ) + warnings.filterwarnings(action="ignore", message="") i = data.gene_ids_of_gene_name(i)[0] gene = data.gene_by_id(i) genes.append( @@ -80,7 +76,7 @@ def _get_annotation(adata, retries=3): ] ) except (IndexError, ValueError) as e: - # print(e) + print(e) genes.append([np.nan, np.nan, np.nan, np.nan]) old_col = adata.var.columns.values adata.var = pd.concat( @@ -136,9 +132,6 @@ def _filter_has_chr(adata): return adata - - - def _atac_genes_score(adata, top_genes=2000, threshold=1, method="beta"): """Calculate gene scores and insert into .obsm.""" import pybedtools @@ -215,17 +208,17 @@ def _atac_genes_score(adata, top_genes=2000, threshold=1, method="beta"): ) # overlap TSS bins with peaks - + x = pybedtools.BedTool.from_dataframe(summits) y = pybedtools.BedTool.from_dataframe(extend_tss) - + tss_to_peaks = x.intersect(y, wb=True, wa=True, loj=True).to_dataframe() # remove non-overlapped TSS and peaks tss_to_peaks = tss_to_peaks.loc[ (tss_to_peaks.thickEnd != ".") | (tss_to_peaks.score != "."), : ] - + if method == "beta": _beta(tss_to_peaks, adata, threshold) elif method == "archr_model21": @@ -338,5 +331,3 @@ def marge(adata, n_top_genes=500): def archr_model21(adata, n_top_genes=500): adata = _atac_genes_score(adata, top_genes=n_top_genes, method="archr_model21") return adata - - diff --git a/openproblems/tasks/regulatory_effect_prediction/methods/maestro.py b/openproblems/tasks/regulatory_effect_prediction/methods/maestro.py index cd8b52527f..34c8722420 100644 --- a/openproblems/tasks/regulatory_effect_prediction/methods/maestro.py +++ b/openproblems/tasks/regulatory_effect_prediction/methods/maestro.py @@ -1,15 +1,19 @@ from ....tools.decorators import method + def _rp_simple(tss_to_peaks, adata): - import scipy import numpy as np - # the coordinates of the current peaks - peaks = adata.uns['mode2_var'] + import scipy + + # the coordinates of the current peaks + peaks = adata.uns["mode2_var"] decay = 10000 - Sg = lambda x: 2**(-x) - gene_distance = 15 * decay + def Sg(x): + return 2 ** (-x) + + # gene_distance = 15 * decay weights = [] for ri, r in tss_to_peaks.iterrows(): @@ -17,11 +21,17 @@ def _rp_simple(tss_to_peaks, adata): summit_chr, tss_summit_start, tss_summit_end = r[:3] tss_extend_chr, tss_extend_start, tss_extend_end = r[4:7] - # print(summit_chr, summit_start, summit_end, extend_chr, extend_start, extend_end) + # print(summit_chr, summit_start, summit_end, + # extend_chr, extend_start, extend_end) sel_chr = [pi for pi in peaks if pi[0] == tss_extend_chr] - sel_peaks = [pi for pi in sel_chr if int(pi[1]) >= tss_extend_start and int(pi[2]) <= tss_extend_end] + sel_peaks = [ + pi + for pi in sel_chr + if int(pi[1]) >= tss_extend_start and int(pi[2]) <= tss_extend_end + ] - # print('# peaks in chromosome', len(sel_chr), '# of peaks around tss', len(sel_peaks)) + # print('# peaks in chromosome', len(sel_chr), + # '# of peaks around tss', len(sel_peaks)) # if len(sel_peaks) > 0: # print(sel_peaks) @@ -31,10 +41,9 @@ def _rp_simple(tss_to_peaks, adata): distance = np.abs(tss_summit_start - summit_peak) # print(pi, distance, Sg(distance / decay)) wi += Sg(distance / decay) - weights.append(wi) - tss_to_peaks['weight'] = weights + tss_to_peaks["weight"] = weights gene_peak_weight = scipy.sparse.csr_matrix( ( @@ -46,10 +55,12 @@ def _rp_simple(tss_to_peaks, adata): adata.obsm["gene_score"] = adata.obsm["mode2"] @ gene_peak_weight.T + @method( method_name="RP_simple", - paper_name="""Integrative analyses of single-cell transcriptome and regulome using MAESTRO.""", - paper_url="https://genomebiology.biomedcentral.com/articles/10.1186/s13059-020-02116-x", + paper_name="""Integrative analyses of single-cell transcriptome\ +and regulome using MAESTRO.""", + paper_url="https://pubmed.ncbi.nlm.nih.gov/32767996", paper_year=2020, code_version="1.0", code_url="https://github.com/liulab-dfci/MAESTRO", @@ -57,5 +68,6 @@ def _rp_simple(tss_to_peaks, adata): ) def rp_simple(adata, n_top_genes=500): from .beta import _atac_genes_score + adata = _atac_genes_score(adata, top_genes=n_top_genes, method="rp_simple") return adata diff --git a/openproblems/tasks/regulatory_effect_prediction/tests/snare_chrompotential_maestro.ipynb b/openproblems/tasks/regulatory_effect_prediction/tests/snare_chrompotential_maestro.ipynb index 2b616a922f..b480cbd12c 100644 --- a/openproblems/tasks/regulatory_effect_prediction/tests/snare_chrompotential_maestro.ipynb +++ b/openproblems/tasks/regulatory_effect_prediction/tests/snare_chrompotential_maestro.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -12,7 +12,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -24,27 +24,89 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ - "adata = datasets.snare_p0_braincortex(test=True)" + "adata = datasets.snare_p0_braincortex(test=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(5081, 19322)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adata.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(4883, 1999)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adata.shape" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "... storing 'chr' as categorical\n", + "... storing 'strand' as categorical\n", + "/home/icb/ignacio.ibarra/miniconda3/envs/openproblems/lib/python3.7/site-packages/pandas/core/arrays/categorical.py:2487: FutureWarning: The `inplace` parameter in pandas.Categorical.remove_unused_categories is deprecated and will be removed in a future version.\n", + " res = method(*args, **kwargs)\n" + ] + } + ], "source": [ "adata = methods.rp_simple(adata, n_top_genes=2000)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "AxisArrays with keys: mode2, gene_score" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "adata.obsm" ] From d46da9935a4321212fa42906320e5fe12207b417 Mon Sep 17 00:00:00 2001 From: ilibarra Date: Wed, 31 Mar 2021 12:29:26 +0200 Subject: [PATCH 4/7] updated rp_enhanced --- .../methods/beta.py | 12 +- .../methods/maestro.py | 213 +++++++++++++++++- .../tests/snare_chrompotential_maestro.ipynb | 156 ++++++++----- 3 files changed, 320 insertions(+), 61 deletions(-) diff --git a/openproblems/tasks/regulatory_effect_prediction/methods/beta.py b/openproblems/tasks/regulatory_effect_prediction/methods/beta.py index 23deac1749..1ea964c440 100644 --- a/openproblems/tasks/regulatory_effect_prediction/methods/beta.py +++ b/openproblems/tasks/regulatory_effect_prediction/methods/beta.py @@ -1,5 +1,6 @@ from ....patch import patch_datacache from ....tools.decorators import method +from .maestro import _rp_enhanced from .maestro import _rp_simple import numpy as np @@ -76,7 +77,8 @@ def _get_annotation(adata, retries=3): ] ) except (IndexError, ValueError) as e: - print(e) + if False: # not interested in showing this during debugging... + print(e) genes.append([np.nan, np.nan, np.nan, np.nan]) old_col = adata.var.columns.values adata.var = pd.concat( @@ -132,7 +134,7 @@ def _filter_has_chr(adata): return adata -def _atac_genes_score(adata, top_genes=2000, threshold=1, method="beta"): +def _atac_genes_score(adata, top_genes=2000, threshold=1, method="beta", **kwargs): """Calculate gene scores and insert into .obsm.""" import pybedtools @@ -188,6 +190,8 @@ def _atac_genes_score(adata, top_genes=2000, threshold=1, method="beta"): axis=1, ) + extend_tss["gene_short_name"] = adata.var["gene_short_name"] + # peak summits peaks = pd.DataFrame( { @@ -226,7 +230,9 @@ def _atac_genes_score(adata, top_genes=2000, threshold=1, method="beta"): elif method == "marge": _marge(tss_to_peaks, adata) elif method == "rp_simple": - _rp_simple(tss_to_peaks, adata) + _rp_simple(tss_to_peaks, adata, **kwargs) + elif method == "rp_enhanced": + _rp_enhanced(tss_to_peaks, adata, **kwargs) return adata diff --git a/openproblems/tasks/regulatory_effect_prediction/methods/maestro.py b/openproblems/tasks/regulatory_effect_prediction/methods/maestro.py index 34c8722420..340a1f64af 100644 --- a/openproblems/tasks/regulatory_effect_prediction/methods/maestro.py +++ b/openproblems/tasks/regulatory_effect_prediction/methods/maestro.py @@ -1,7 +1,9 @@ from ....tools.decorators import method +import pandas as pd -def _rp_simple(tss_to_peaks, adata): + +def _rp_simple(tss_to_peaks, adata, log_each=500): import numpy as np import scipy @@ -16,6 +18,12 @@ def Sg(x): # gene_distance = 15 * decay weights = [] + + tss_to_peaks = tss_to_peaks.drop_duplicates("itemRgb") + + # print(tss_to_peaks.shape) + # print(tss_to_peaks.head()) + for ri, r in tss_to_peaks.iterrows(): wi = 0 summit_chr, tss_summit_start, tss_summit_end = r[:3] @@ -41,6 +49,14 @@ def Sg(x): distance = np.abs(tss_summit_start - summit_peak) # print(pi, distance, Sg(distance / decay)) wi += Sg(distance / decay) + + if log_each is not None and len(weights) % log_each == 0: + print( + "# weights calculated so far", + len(weights), + "out of", + tss_to_peaks.shape[0], + ) weights.append(wi) tss_to_peaks["weight"] = weights @@ -56,6 +72,178 @@ def Sg(x): adata.obsm["gene_score"] = adata.obsm["mode2"] @ gene_peak_weight.T +# this function is the implementation from MAESTRO to load exonic annotations +def _extract_gene_info(gene_bed): + """Extract gene information from gene bed file.""" + + bed = pd.read_csv(gene_bed, sep="\t", header=0, compression="gzip") + + # remove null names + bed = bed[~pd.isnull(bed["name"])] + + bed["transcript"] = [x.strip().split(".")[0] for x in bed["name"].tolist()] + bed["tss"] = bed.apply( + lambda x: x["txStart"] if x["strand"] == "+" else x["txEnd"], axis=1 + ) + + # adjacent P+GB + bed["start"] = bed.apply( + lambda x: x["txStart"] - 2000 if x["strand"] == "+" else x["txStart"], axis=1 + ) + bed["end"] = bed.apply( + lambda x: x["txEnd"] + 2000 if x["strand"] == "-" else x["txEnd"], axis=1 + ) + + bed["promoter"] = bed.apply( + lambda x: tuple([x["tss"] - 2000, x["tss"] + 2000]), axis=1 + ) + bed["exons"] = bed.apply( + lambda x: tuple( + [ + (int(i), int(j)) + for i, j in zip( + x["exonStarts"].strip(",").split(","), + x["exonEnds"].strip(",").split(","), + ) + ] + ), + axis=1, + ) + + # exon length + bed["length"] = bed.apply( + lambda x: sum(list(map(lambda i: (i[1] - i[0]) / 1000.0, x["exons"]))), axis=1 + ) + bed["uid"] = bed.apply( + lambda x: "%s@%s@%s" % (x["name2"], x["start"], x["end"]), axis=1 + ) + bed = bed.drop_duplicates(subset="uid", keep="first") + gene_info = [] + for irow, x in bed.iterrows(): + gene_info.append( + [ + x["chrom"], + x["start"], + x["end"], + x["tss"], + x["promoter"], + x["exons"], + x["length"], + 1, + x["uid"], + ] + ) + # [chrom_0, start_1, end_2, tss_3, promoter_4, exons_5, length_6, 1_7, uid_8] + return gene_info + + +def _rp_enhanced(tss_to_peaks, adata, log_each=500): + import numpy as np + import scipy + + # load the exonic annotations from a template annotations file. + # Infer species name using the adata.uns['species'] variable + exon_annot_path = "../datasets/annotations/GRC%s38_refgenes.txt.gz" % ( + "m" if adata.uns["species"] == "mus_musculus" else "h" + ) + exons_info = _extract_gene_info(exon_annot_path) + + # map exon information to tss_to_peaks in order to use it + exon_df = pd.DataFrame( + exons_info, + columns=[ + "chr", + "start", + "end", + "4", + "range", + "exon.coordinates", + "score1", + "score2", + "ud", + ], + ) + exon_df["name"] = exon_df["ud"].str.split("@").str[0] + exon_df = exon_df.drop_duplicates("name") + exon_df.index = exon_df["name"] + adata.var["exon.ranges"] = exon_df.reindex(adata.var.index)["exon.coordinates"] + exon_coordinates_by_gene = exon_df.set_index("name")["exon.coordinates"].to_dict() + tss_to_peaks["exon.ranges"] = tss_to_peaks["itemRgb"].map(exon_coordinates_by_gene) + + tss_to_peaks = tss_to_peaks.drop_duplicates("itemRgb") + + # the coordinates of the current peaks + peaks = adata.uns["mode2_var"] + + decay = 10000 + + def Sg(x): + return 2 ** (-x) + + weights = [] + for ri, r in tss_to_peaks.iterrows(): + wi = 0 + summit_chr, tss_summit_start, tss_summit_end = r[:3] + tss_extend_chr, tss_extend_start, tss_extend_end = r[4:7] + + # gene_name = r[-2] + exon_ranges = r[-1] + + # print(summit_chr, tss_summit_start, tss_summit_end, + # tss_extend_chr, tss_extend_start, tss_extend_end, + # gene_name, exon_ranges) + sel_chr = [pi for pi in peaks if pi[0] == tss_extend_chr] + sel_peaks = [ + pi + for pi in sel_chr + if int(pi[1]) >= tss_extend_start and int(pi[2]) <= tss_extend_end + ] + + # check whether the peak overlaps with a given exon + if not pd.isnull(exon_ranges): + sel_peak_summits = [(int(pi[1]) + int(pi[2])) / 2.0 for pi in sel_peaks] + peak_in_exons = [ + np.sum([ps >= ex[0] and ps <= ex[1] for ex in exon_ranges]) >= 1 + for ps in sel_peak_summits + ] + else: + peak_in_exons = [False for pi in sel_peaks] + + # print(sel_peaks, peak_in_exons) + # if peaks then this is take them into account, one by one + for pi, peak_in_exon in zip(sel_peaks, peak_in_exons): + # the current peak is part of an exon + # if peak_in_exon: + # print(pi) + summit_peak = int((int(pi[2]) + int(pi[1])) / 2) + distance = np.abs(tss_summit_start - summit_peak) + # print(pi, distance, Sg(distance / decay)) + wi += Sg(distance / decay) if not peak_in_exon else 1.0 + + if log_each is not None and len(weights) % log_each == 0: + print( + "# weights calculated so far", + len(weights), + "out of", + tss_to_peaks.shape[0], + ) + + weights.append(wi) + + out = tss_to_peaks.copy() + out["weight"] = weights + + gene_peak_weight = scipy.sparse.csr_matrix( + ( + out.weight.values, + (out.thickEnd.astype("int32").values, out.name.values), + ), + shape=(adata.shape[1], adata.uns["mode2_var"].shape[0]), + ) + + adata.obsm["gene_score"] = adata.obsm["mode2"] @ gene_peak_weight.T + + @method( method_name="RP_simple", paper_name="""Integrative analyses of single-cell transcriptome\ @@ -69,5 +257,26 @@ def Sg(x): def rp_simple(adata, n_top_genes=500): from .beta import _atac_genes_score - adata = _atac_genes_score(adata, top_genes=n_top_genes, method="rp_simple") + adata = _atac_genes_score( + adata, + top_genes=n_top_genes, + method="rp_simple", + ) + return adata + + +@method( + method_name="RP_enhanced", + paper_name="""Integrative analyses of single-cell transcriptome\ +and regulome using MAESTRO.""", + paper_url="https://pubmed.ncbi.nlm.nih.gov/32767996", + paper_year=2020, + code_version="1.0", + code_url="https://github.com/liulab-dfci/MAESTRO", + image="openproblems-python-extras", +) +def rp_enhanced(adata, n_top_genes=500): + from .beta import _atac_genes_score + + adata = _atac_genes_score(adata, top_genes=n_top_genes, method="rp_enhanced") return adata diff --git a/openproblems/tasks/regulatory_effect_prediction/tests/snare_chrompotential_maestro.ipynb b/openproblems/tasks/regulatory_effect_prediction/tests/snare_chrompotential_maestro.ipynb index b480cbd12c..29a2304628 100644 --- a/openproblems/tasks/regulatory_effect_prediction/tests/snare_chrompotential_maestro.ipynb +++ b/openproblems/tasks/regulatory_effect_prediction/tests/snare_chrompotential_maestro.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -12,68 +12,56 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "%load_ext autoreload\n", "%autoreload 2\n", - "from openproblems.tasks.regulatory_effect_prediction import datasets, methods\n", - "\n" + "from openproblems.tasks.regulatory_effect_prediction import datasets, methods\n" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 63, "metadata": {}, "outputs": [], "source": [ + "# test = False does not work as tss_to_peaks need to be sub-sampled, and it seems that everything is blended.\n", "adata = datasets.snare_p0_braincortex(test=False)" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 64, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(5081, 19322)" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "adata.shape" + "# the genes will only be limited to chromosome 1`(faster calculation, no randomness)" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 65, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(4883, 1999)" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], + "source": [ + "# this indicates the number of genes we will test simultaneously in our \n", + "n_genes = 2000" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [], "source": [ - "adata.shape" + "adata_sample = adata[:,adata.var.index.isin(adata.var.head(n_genes).index)]" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 77, "metadata": {}, "outputs": [ { @@ -85,58 +73,114 @@ "/home/icb/ignacio.ibarra/miniconda3/envs/openproblems/lib/python3.7/site-packages/pandas/core/arrays/categorical.py:2487: FutureWarning: The `inplace` parameter in pandas.Categorical.remove_unused_categories is deprecated and will be removed in a future version.\n", " res = method(*args, **kwargs)\n" ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "# weights calculated so far 0 out of 1452\n", + "# weights calculated so far 500 out of 1452\n", + "# weights calculated so far 1000 out of 1452\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/mnt/znas/icb_zstore01/groups/ml01/workspace/ignacio.ibarra/SingleCellOpenProblems/openproblems/tasks/regulatory_effect_prediction/methods/maestro.py:57: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shape=(adata.shape[1], adata.uns[\"mode2_var\"].shape[0]),\n" + ] } ], "source": [ - "adata = methods.rp_simple(adata, n_top_genes=2000)" + "adata_sample = methods.rp_simple(adata_sample, n_top_genes=2000) # log_each=10)" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 78, "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "AxisArrays with keys: mode2, gene_score" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "(-0.017173285122470874, -0.011103724554606167)\n" + ] } ], "source": [ - "adata.obsm" + "%autoreload 2\n", + "\n", + "import seaborn as sns\n", + "from openproblems.tasks.regulatory_effect_prediction import metrics\n", + "\n", + "cors = metrics.spearman_correlation(adata_sample), metrics.pearson_correlation(adata_sample)\n", + "print(cors)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 79, "metadata": {}, "outputs": [], "source": [ - "%autoreload 2\n", - "\n", - "import seaborn as sns\n", - "from openproblems.tasks.regulatory_effect_prediction import metrics\n", - "cors = metrics.spearman_correlation(adata)\n", - "print(cors)" + "adata_sample = adata[:,adata.var.index.isin(adata.var.head(n_genes).index)]" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 80, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "... storing 'chr' as categorical\n", + "... storing 'strand' as categorical\n", + "/home/icb/ignacio.ibarra/miniconda3/envs/openproblems/lib/python3.7/site-packages/pandas/core/arrays/categorical.py:2487: FutureWarning: The `inplace` parameter in pandas.Categorical.remove_unused_categories is deprecated and will be removed in a future version.\n", + " res = method(*args, **kwargs)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "# weights calculated so far 0 out of 1452\n", + "# weights calculated so far 500 out of 1452\n", + "# weights calculated so far 1000 out of 1452\n" + ] + } + ], + "source": [ + "adata_sample = methods.rp_enhanced(adata_sample, n_top_genes=2000)" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(-0.017543645705293393, -0.011540115273533868)\n" + ] + } + ], "source": [ "%autoreload 2\n", "\n", - "from openproblems.tasks.regulatory_effect_prediction import metrics\n", "import seaborn as sns\n", - "cors = metrics.pearson_correlation(adata)\n", + "from openproblems.tasks.regulatory_effect_prediction import metrics\n", "\n", + "cors = metrics.spearman_correlation(adata_sample), metrics.pearson_correlation(adata_sample)\n", "print(cors)" ] } From fe4b370be292b533cb8b9704738b6843133a3fb5 Mon Sep 17 00:00:00 2001 From: ilibarra Date: Wed, 31 Mar 2021 16:33:47 +0200 Subject: [PATCH 5/7] updating functions to remove usage of local files... --- .../methods/__init__.py | 1 + .../methods/beta.py | 33 +- .../methods/maestro.py | 138 ++---- .../tests/snare_chrompotential_maestro.ipynb | 450 ++++++++++++++++-- 4 files changed, 447 insertions(+), 175 deletions(-) diff --git a/openproblems/tasks/regulatory_effect_prediction/methods/__init__.py b/openproblems/tasks/regulatory_effect_prediction/methods/__init__.py index c050b84190..683566546a 100644 --- a/openproblems/tasks/regulatory_effect_prediction/methods/__init__.py +++ b/openproblems/tasks/regulatory_effect_prediction/methods/__init__.py @@ -1,4 +1,5 @@ from .beta import archr_model21 from .beta import beta from .beta import marge +from .maestro import rp_enhanced from .maestro import rp_simple diff --git a/openproblems/tasks/regulatory_effect_prediction/methods/beta.py b/openproblems/tasks/regulatory_effect_prediction/methods/beta.py index 1ea964c440..e8ede814f8 100644 --- a/openproblems/tasks/regulatory_effect_prediction/methods/beta.py +++ b/openproblems/tasks/regulatory_effect_prediction/methods/beta.py @@ -30,6 +30,7 @@ def _chrom_limit(x, tss_size=2e5): return [gene_end - tss_size // 2, gene_end + tss_size // 2] +# included 2-3 lines to make it run with exons. def _get_annotation(adata, retries=3): """Insert meta data into adata.obs.""" from pyensembl import EnsemblRelease @@ -52,20 +53,19 @@ def _get_annotation(adata, retries=3): for i in adata.var.index.map(lambda x: x.split(".")[0]): try: with warnings.catch_warnings(): - warnings.filterwarnings(action="ignore", message="") + warnings.filterwarnings( + action="ignore", message="No results found for query" + ) gene = data.gene_by_id(i) genes.append( - [ - "chr%s" % gene.contig, - gene.start, - gene.end, - gene.strand, - ] + ["chr%s" % gene.contig, gene.start, gene.end, gene.strand, gene.exons] ) except ValueError: try: with warnings.catch_warnings(): - warnings.filterwarnings(action="ignore", message="") + warnings.filterwarnings( + action="ignore", message="No results found for query" + ) i = data.gene_ids_of_gene_name(i)[0] gene = data.gene_by_id(i) genes.append( @@ -74,18 +74,18 @@ def _get_annotation(adata, retries=3): gene.start, gene.end, gene.strand, + gene.exons, ] ) except (IndexError, ValueError) as e: - if False: # not interested in showing this during debugging... - print(e) + print(e) genes.append([np.nan, np.nan, np.nan, np.nan]) old_col = adata.var.columns.values adata.var = pd.concat( [adata.var, pd.DataFrame(genes, index=adata.var_names)], axis=1 ) adata.var.columns = np.hstack( - [old_col, np.array(["chr", "start", "end", "strand"])] + [old_col, np.array(["chr", "start", "end", "strand", "exons"])] ) @@ -230,9 +230,16 @@ def _atac_genes_score(adata, top_genes=2000, threshold=1, method="beta", **kwarg elif method == "marge": _marge(tss_to_peaks, adata) elif method == "rp_simple": - _rp_simple(tss_to_peaks, adata, **kwargs) + _rp_simple(tss_to_peaks, adata) elif method == "rp_enhanced": - _rp_enhanced(tss_to_peaks, adata, **kwargs) + _rp_enhanced(tss_to_peaks, adata) + + # the genes and gene_scores have to have the same dimensions + same_shape = adata.shape == adata.obsm["gene_score"].shape + if not same_shape: + print(adata.shape, adata.obsm["gene_score"].shape) + print("dimensions are not the same. Check calculation/filters") + assert same_shape return adata diff --git a/openproblems/tasks/regulatory_effect_prediction/methods/maestro.py b/openproblems/tasks/regulatory_effect_prediction/methods/maestro.py index 340a1f64af..9389d7f34d 100644 --- a/openproblems/tasks/regulatory_effect_prediction/methods/maestro.py +++ b/openproblems/tasks/regulatory_effect_prediction/methods/maestro.py @@ -51,12 +51,13 @@ def Sg(x): wi += Sg(distance / decay) if log_each is not None and len(weights) % log_each == 0: - print( - "# weights calculated so far", - len(weights), - "out of", - tss_to_peaks.shape[0], - ) + if len(weights) > 0: + print( + "# weights calculated so far", + len(weights), + "out of", + tss_to_peaks.shape[0], + ) weights.append(wi) tss_to_peaks["weight"] = weights @@ -72,105 +73,19 @@ def Sg(x): adata.obsm["gene_score"] = adata.obsm["mode2"] @ gene_peak_weight.T -# this function is the implementation from MAESTRO to load exonic annotations -def _extract_gene_info(gene_bed): - """Extract gene information from gene bed file.""" - - bed = pd.read_csv(gene_bed, sep="\t", header=0, compression="gzip") - - # remove null names - bed = bed[~pd.isnull(bed["name"])] - - bed["transcript"] = [x.strip().split(".")[0] for x in bed["name"].tolist()] - bed["tss"] = bed.apply( - lambda x: x["txStart"] if x["strand"] == "+" else x["txEnd"], axis=1 - ) - - # adjacent P+GB - bed["start"] = bed.apply( - lambda x: x["txStart"] - 2000 if x["strand"] == "+" else x["txStart"], axis=1 - ) - bed["end"] = bed.apply( - lambda x: x["txEnd"] + 2000 if x["strand"] == "-" else x["txEnd"], axis=1 - ) - - bed["promoter"] = bed.apply( - lambda x: tuple([x["tss"] - 2000, x["tss"] + 2000]), axis=1 - ) - bed["exons"] = bed.apply( - lambda x: tuple( - [ - (int(i), int(j)) - for i, j in zip( - x["exonStarts"].strip(",").split(","), - x["exonEnds"].strip(",").split(","), - ) - ] - ), - axis=1, - ) - - # exon length - bed["length"] = bed.apply( - lambda x: sum(list(map(lambda i: (i[1] - i[0]) / 1000.0, x["exons"]))), axis=1 - ) - bed["uid"] = bed.apply( - lambda x: "%s@%s@%s" % (x["name2"], x["start"], x["end"]), axis=1 - ) - bed = bed.drop_duplicates(subset="uid", keep="first") - gene_info = [] - for irow, x in bed.iterrows(): - gene_info.append( - [ - x["chrom"], - x["start"], - x["end"], - x["tss"], - x["promoter"], - x["exons"], - x["length"], - 1, - x["uid"], - ] - ) - # [chrom_0, start_1, end_2, tss_3, promoter_4, exons_5, length_6, 1_7, uid_8] - return gene_info - - def _rp_enhanced(tss_to_peaks, adata, log_each=500): import numpy as np import scipy - # load the exonic annotations from a template annotations file. - # Infer species name using the adata.uns['species'] variable - exon_annot_path = "../datasets/annotations/GRC%s38_refgenes.txt.gz" % ( - "m" if adata.uns["species"] == "mus_musculus" else "h" - ) - exons_info = _extract_gene_info(exon_annot_path) - - # map exon information to tss_to_peaks in order to use it - exon_df = pd.DataFrame( - exons_info, - columns=[ - "chr", - "start", - "end", - "4", - "range", - "exon.coordinates", - "score1", - "score2", - "ud", - ], - ) - exon_df["name"] = exon_df["ud"].str.split("@").str[0] - exon_df = exon_df.drop_duplicates("name") - exon_df.index = exon_df["name"] - adata.var["exon.ranges"] = exon_df.reindex(adata.var.index)["exon.coordinates"] - exon_coordinates_by_gene = exon_df.set_index("name")["exon.coordinates"].to_dict() - tss_to_peaks["exon.ranges"] = tss_to_peaks["itemRgb"].map(exon_coordinates_by_gene) + # prepare the exonic ranges + exon_ranges = [] + for exons in adata.var["exons"]: + exon_ranges.append([e.start, e.end] for e in exons) + adata.var["exon.ranges"] = exon_ranges + exon_coordinates_by_gene = adata.var["exon.ranges"].to_dict() - tss_to_peaks = tss_to_peaks.drop_duplicates("itemRgb") + tss_to_peaks["exon.ranges"] = tss_to_peaks["itemRgb"].map(exon_coordinates_by_gene) + tss_to_peaks = tss_to_peaks.drop_duplicates("itemRgb").reset_index(drop=True) # the coordinates of the current peaks peaks = adata.uns["mode2_var"] @@ -180,6 +95,7 @@ def _rp_enhanced(tss_to_peaks, adata, log_each=500): def Sg(x): return 2 ** (-x) + print("calculating weights per gene...") weights = [] for ri, r in tss_to_peaks.iterrows(): wi = 0 @@ -198,7 +114,6 @@ def Sg(x): for pi in sel_chr if int(pi[1]) >= tss_extend_start and int(pi[2]) <= tss_extend_end ] - # check whether the peak overlaps with a given exon if not pd.isnull(exon_ranges): sel_peak_summits = [(int(pi[1]) + int(pi[2])) / 2.0 for pi in sel_peaks] @@ -209,7 +124,9 @@ def Sg(x): else: peak_in_exons = [False for pi in sel_peaks] - # print(sel_peaks, peak_in_exons) + # if sum(peak_in_exons) > 0: + # print ('exon / peak overlap found!') + # print(ri, peak_in_exons) # if peaks then this is take them into account, one by one for pi, peak_in_exon in zip(sel_peaks, peak_in_exons): # the current peak is part of an exon @@ -221,12 +138,13 @@ def Sg(x): wi += Sg(distance / decay) if not peak_in_exon else 1.0 if log_each is not None and len(weights) % log_each == 0: - print( - "# weights calculated so far", - len(weights), - "out of", - tss_to_peaks.shape[0], - ) + if len(weights) > 0: + print( + "# weights calculated so far", + len(weights), + "out of", + tss_to_peaks.shape[0], + ) weights.append(wi) @@ -254,7 +172,7 @@ def Sg(x): code_url="https://github.com/liulab-dfci/MAESTRO", image="openproblems-python-extras", ) -def rp_simple(adata, n_top_genes=500): +def rp_simple(adata, n_top_genes=2000): from .beta import _atac_genes_score adata = _atac_genes_score( @@ -275,7 +193,7 @@ def rp_simple(adata, n_top_genes=500): code_url="https://github.com/liulab-dfci/MAESTRO", image="openproblems-python-extras", ) -def rp_enhanced(adata, n_top_genes=500): +def rp_enhanced(adata, n_top_genes=2000): from .beta import _atac_genes_score adata = _atac_genes_score(adata, top_genes=n_top_genes, method="rp_enhanced") diff --git a/openproblems/tasks/regulatory_effect_prediction/tests/snare_chrompotential_maestro.ipynb b/openproblems/tasks/regulatory_effect_prediction/tests/snare_chrompotential_maestro.ipynb index 29a2304628..8435144360 100644 --- a/openproblems/tasks/regulatory_effect_prediction/tests/snare_chrompotential_maestro.ipynb +++ b/openproblems/tasks/regulatory_effect_prediction/tests/snare_chrompotential_maestro.ipynb @@ -2,66 +2,275 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 93, "metadata": {}, "outputs": [], "source": [ - "import pandas as pd\n", - "import numpy as np" + "%load_ext autoreload\n", + "%autoreload 2\n", + "from openproblems.tasks.regulatory_effect_prediction import datasets, methods" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "## I. Use the utility function to prepare a subset of genes that are HVG and also mappable to chromosomes/TSS" ] }, { "cell_type": "code", - "execution_count": 2, - "metadata": {}, + "execution_count": 150, + "metadata": { + "jupyter": { + "source_hidden": true + }, + "tags": [] + }, "outputs": [], "source": [ - "%load_ext autoreload\n", - "%autoreload 2\n", - "from openproblems.tasks.regulatory_effect_prediction import datasets, methods\n" + "from openproblems.patch import patch_datacache\n", + "import numpy as np\n", + "import pandas as pd\n", + "import scanpy as sc\n", + "import warnings\n", + "\n", + "def _chrom_limit(x, tss_size=2e5):\n", + " \"\"\"Extend TSS to upstream and downstream intervals.\n", + "\n", + " Parameters\n", + " ----------\n", + " x : pd.Series\n", + " a pd.Series containing [start, end, direction]\n", + " where start and end are ints and direction is {'+', '-'}.\n", + " tss_size: int\n", + " a int that defines the upstream and downstream regions around TSS\n", + " \"\"\"\n", + " y = x.values\n", + " gene_direction = y[-1]\n", + " gene_start = y[-3]\n", + " gene_end = y[-2]\n", + " if gene_direction == \"+\":\n", + " return [gene_start - tss_size // 2, gene_start + tss_size // 2]\n", + " else:\n", + " return [gene_end - tss_size // 2, gene_end + tss_size // 2]\n", + "\n", + "\n", + "def _get_annotation(adata, retries=3):\n", + " \"\"\"Insert meta data into adata.obs.\"\"\"\n", + " from pyensembl import EnsemblRelease\n", + "\n", + " data = EnsemblRelease(\n", + " adata.uns[\"release\"],\n", + " adata.uns[\"species\"],\n", + " )\n", + " for _ in range(retries):\n", + " try:\n", + " with patch_datacache():\n", + " data.download(overwrite=False)\n", + " data.index(overwrite=False)\n", + " break\n", + " except TimeoutError:\n", + " pass\n", + "\n", + " # get ensemble gene coordinate\n", + " genes = []\n", + " for i in adata.var.index.map(lambda x: x.split(\".\")[0]):\n", + " try:\n", + " with warnings.catch_warnings():\n", + " warnings.filterwarnings(\n", + " action=\"ignore\", message=\"No results found for query\"\n", + " )\n", + " gene = data.gene_by_id(i)\n", + " genes.append(\n", + " [\n", + " \"chr%s\" % gene.contig,\n", + " gene.start,\n", + " gene.end,\n", + " gene.strand,\n", + " gene.exons\n", + " ]\n", + " )\n", + " except ValueError:\n", + " try:\n", + " with warnings.catch_warnings():\n", + " warnings.filterwarnings(\n", + " action=\"ignore\", message=\"No results found for query\"\n", + " )\n", + " i = data.gene_ids_of_gene_name(i)[0]\n", + " gene = data.gene_by_id(i)\n", + " genes.append(\n", + " [\n", + " \"chr%s\" % gene.contig,\n", + " gene.start,\n", + " gene.end,\n", + " gene.strand,\n", + " gene.exons \n", + " ]\n", + " )\n", + " except (IndexError, ValueError) as e:\n", + " # print(e)\n", + " genes.append([np.nan, np.nan, np.nan, np.nan])\n", + " old_col = adata.var.columns.values\n", + " adata.var = pd.concat(\n", + " [adata.var, pd.DataFrame(genes, index=adata.var_names)], axis=1\n", + " )\n", + " adata.var.columns = np.hstack(\n", + " [old_col, np.array([\"chr\", \"start\", \"end\", \"strand\", 'exons'])]\n", + " )\n", + "\n", + "\n", + "def _filter_mitochondrial(adata):\n", + " if adata.uns[\"species\"] in [\"mus_musculus\", \"homo_sapiens\"]:\n", + " adata.var[\"mt\"] = adata.var.gene_short_name.str.lower().str.startswith(\n", + " \"mt-\"\n", + " ) # annotate the group of mitochondrial genes as 'mt'\n", + " sc.pp.calculate_qc_metrics(\n", + " adata, qc_vars=[\"mt\"], percent_top=None, log1p=False, inplace=True\n", + " )\n", + "\n", + " adata_filter = adata[adata.obs.pct_counts_mt <= 10]\n", + " if adata_filter.shape[0] > 100:\n", + " adata = adata_filter.copy()\n", + " return adata\n", + "\n", + "\n", + "def _filter_n_genes_max(adata):\n", + " adata_filter = adata[adata.obs.n_genes_by_counts <= 2000]\n", + " if adata_filter.shape[0] > 100:\n", + " adata = adata_filter.copy()\n", + " return adata\n", + "\n", + "\n", + "def _filter_n_genes_min(adata):\n", + " adata_filter = adata.copy()\n", + " sc.pp.filter_cells(adata_filter, min_genes=200)\n", + " if adata_filter.shape[0] > 100:\n", + " adata = adata_filter\n", + " return adata\n", + "\n", + "\n", + "def _filter_n_cells(adata):\n", + " adata_filter = adata.copy()\n", + " sc.pp.filter_genes(adata_filter, min_cells=5)\n", + " if adata_filter.shape[1] > 100:\n", + " adata = adata_filter\n", + " return adata\n", + "\n", + "\n", + "def _filter_has_chr(adata):\n", + " adata_filter = adata[:, ~pd.isnull(adata.var.loc[:, \"chr\"])].copy()\n", + " if adata_filter.shape[1] > 100:\n", + " adata = adata_filter\n", + " return adata" ] }, { - "cell_type": "code", - "execution_count": 63, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "# test = False does not work as tss_to_peaks need to be sub-sampled, and it seems that everything is blended.\n", - "adata = datasets.snare_p0_braincortex(test=False)" + "**This step takes like five minutes for the whole object. Please wait.**\n", + "## In the context of testing, the pre-analysis here check for genes that are\n", + "i. Highly variable.\n", + "ii. Chromosome+exons mappable." ] }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 216, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "obtaining annotation...\n", + "done...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "... storing 'chr' as categorical\n", + "... storing 'strand' as categorical\n" + ] + } + ], + "source": [ + "# test = False does not work as tss_to_peaks need to be sub-sampled, and it seems that everything is blended.\n", + "adata = datasets.snare_p0_braincortex(test=False)\n", + "\n", + "top_genes = 2000\n", + "sc.pp.normalize_total(adata, target_sum=1e4)\n", + "sc.pp.log1p(adata)\n", + "\n", + "if top_genes <= adata.shape[1]:\n", + " sc.pp.highly_variable_genes(adata, n_top_genes=top_genes)\n", + " adata = adata[:, adata.var.highly_variable].copy()\n", + " \n", + "# get annotation for TSS\n", + "print('obtaining annotation...')\n", + "_get_annotation(adata)\n", + "print('done...')\n", + "\n", + "# basic quality control\n", + "adata = _filter_has_chr(adata)\n", + "adata = _filter_mitochondrial(adata)\n", + "adata = _filter_n_genes_max(adata)\n", + "adata = _filter_n_genes_min(adata)\n", + "adata = _filter_n_cells(adata)\n", + "\n", + "# regress out and scale\n", + "sc.pp.regress_out(adata, [\"total_counts\", \"pct_counts_mt\"])\n", + "sc.pp.scale(adata, max_value=10)\n", + "\n", + "sel_genes = set(adata.var.index)" + ] + }, + { + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "# the genes will only be limited to chromosome 1`(faster calculation, no randomness)" + "## II. Once an annotation has been prepared, we test the main approaches" ] }, { "cell_type": "code", - "execution_count": 65, + "execution_count": 287, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "before filtering (5081, 19322)\n", + "after filtering (5081, 1234)\n" + ] + } + ], "source": [ - "# this indicates the number of genes we will test simultaneously in our \n", - "n_genes = 2000" + "# test = False does not work as tss_to_peaks need to be sub-sampled, and it seems that everything is blended.\n", + "adata = datasets.snare_p0_braincortex(test=False)\n", + "print('before filtering', adata.shape)\n", + "adata = adata[:, adata.var.index.isin(sel_genes)]\n", + "print('after filtering', adata.shape)" ] }, { - "cell_type": "code", - "execution_count": 76, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "adata_sample = adata[:,adata.var.index.isin(adata.var.head(n_genes).index)]" + "## RP-basic" ] }, { "cell_type": "code", - "execution_count": 77, + "execution_count": 231, "metadata": {}, "outputs": [ { @@ -78,63 +287,141 @@ "name": "stdout", "output_type": "stream", "text": [ - "# weights calculated so far 0 out of 1452\n", - "# weights calculated so far 500 out of 1452\n", - "# weights calculated so far 1000 out of 1452\n" + "# weights calculated so far 500 out of 1232\n", + "# weights calculated so far 1000 out of 1232\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/mnt/znas/icb_zstore01/groups/ml01/workspace/ignacio.ibarra/SingleCellOpenProblems/openproblems/tasks/regulatory_effect_prediction/methods/maestro.py:57: SettingWithCopyWarning: \n", + "/mnt/znas/icb_zstore01/groups/ml01/workspace/ignacio.ibarra/SingleCellOpenProblems/openproblems/tasks/regulatory_effect_prediction/methods/maestro.py:63: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shape=(adata.shape[1], adata.uns[\"mode2_var\"].shape[0]),\n" + " \n" ] } ], "source": [ - "adata_sample = methods.rp_simple(adata_sample, n_top_genes=2000) # log_each=10)" + "adata = methods.rp_simple(adata, n_top_genes=2000) # log_each=10)" ] }, { "cell_type": "code", - "execution_count": 78, + "execution_count": 291, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "(-0.017173285122470874, -0.011103724554606167)\n" + "ename": "KeyError", + "evalue": "'gene_score'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mseaborn\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0msns\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mopenproblems\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtasks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mregulatory_effect_prediction\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mmetrics\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mcors\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmetrics\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mspearman_correlation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0madata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetrics\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpearson_correlation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0madata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcors\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/mnt/znas/icb_zstore01/groups/ml01/workspace/ignacio.ibarra/SingleCellOpenProblems/openproblems/tools/decorators.py\u001b[0m in \u001b[0;36mapply_metric\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 107\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mapply_metric\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 108\u001b[0m \u001b[0mlog\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Running {} metric\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 109\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 110\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 111\u001b[0m apply_metric.metadata = dict(\n", + "\u001b[0;32m/mnt/znas/icb_zstore01/groups/ml01/workspace/ignacio.ibarra/SingleCellOpenProblems/openproblems/tasks/regulatory_effect_prediction/metrics/correlation.py\u001b[0m in \u001b[0;36mspearman_correlation\u001b[0;34m(adata)\u001b[0m\n\u001b[1;32m 39\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mmetric\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmetric_name\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"Median Spearman correlation\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmaximize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 40\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mspearman_correlation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0madata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 41\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0m_metric\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0madata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"spearman\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 42\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 43\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/mnt/znas/icb_zstore01/groups/ml01/workspace/ignacio.ibarra/SingleCellOpenProblems/openproblems/tasks/regulatory_effect_prediction/metrics/correlation.py\u001b[0m in \u001b[0;36m_metric\u001b[0;34m(adata, method)\u001b[0m\n\u001b[1;32m 19\u001b[0m x = (\n\u001b[1;32m 20\u001b[0m \u001b[0madata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mobsm\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"gene_score\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtoarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 21\u001b[0;31m \u001b[0;32mif\u001b[0m \u001b[0mscipy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msparse\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0missparse\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0madata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mobsm\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"gene_score\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 22\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0madata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mobsm\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"gene_score\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 23\u001b[0m )\n", + "\u001b[0;32m~/miniconda3/envs/openproblems/lib/python3.7/site-packages/anndata/_core/aligned_mapping.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 146\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 147\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__getitem__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mV\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 148\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 149\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 150\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__setitem__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mV\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 'gene_score'" ] } ], "source": [ "%autoreload 2\n", - "\n", "import seaborn as sns\n", "from openproblems.tasks.regulatory_effect_prediction import metrics\n", - "\n", - "cors = metrics.spearman_correlation(adata_sample), metrics.pearson_correlation(adata_sample)\n", + "cors = metrics.spearman_correlation(adata), metrics.pearson_correlation(adata)\n", "print(cors)" ] }, { "cell_type": "code", - "execution_count": 79, + "execution_count": 260, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(5081, 1233) (5081, 1233)\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'correlations')" + ] + }, + "execution_count": 260, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "sc.pp.neighbors(adata, n_neighbors=300)\n", + "adata.layers['X_knn'] = adata.obsp['connectivities'].dot(adata.X)\n", + "adata.layers['gene_score_knn'] = adata.obsp['connectivities'].dot(adata.obsm[\"gene_score\"])\n", + "print(adata.layers['X_knn'].shape, adata.layers['gene_score_knn'].shape)\n", + "from scipy.stats import pearsonr\n", + "cors = []\n", + "for i in range(adata.layers['X_knn'].shape[0]):\n", + " x = adata.layers['X_knn'][i,:]\n", + " y = adata.layers['gene_score_knn'][i,:].toarray().flatten()\n", + " cors.append(pearsonr(x, y))\n", + "cors_cor = list(map(lambda x: x[0], cors))\n", + "sns.kdeplot(np.array(list(cors_cor)))\n", + "plt.xlabel('correlations')" + ] + }, + { + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "adata_sample = adata[:,adata.var.index.isin(adata.var.head(n_genes).index)]" + "## RP-enhanced" ] }, { "cell_type": "code", - "execution_count": 80, + "execution_count": 314, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "before filtering (5081, 19322)\n", + "after filtering (5081, 1234)\n" + ] + } + ], + "source": [ + "# test = False does not work as tss_to_peaks need to be sub-sampled, and it seems that everything is blended.\n", + "adata = datasets.snare_p0_braincortex(test=False)\n", + "print('before filtering', adata.shape)\n", + "adata = adata[:, adata.var.index.isin(sel_genes)]\n", + "print('after filtering', adata.shape)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 315, "metadata": {}, "outputs": [ { @@ -151,38 +438,97 @@ "name": "stdout", "output_type": "stream", "text": [ - "# weights calculated so far 0 out of 1452\n", - "# weights calculated so far 500 out of 1452\n", - "# weights calculated so far 1000 out of 1452\n" + "calculating weights per gene...\n", + "# weights calculated so far 500 out of 1232\n", + "# weights calculated so far 1000 out of 1232\n" ] } ], "source": [ - "adata_sample = methods.rp_enhanced(adata_sample, n_top_genes=2000)" + "adata = methods.rp_enhanced(adata, n_top_genes=2000) # log_each=10)" ] }, { "cell_type": "code", - "execution_count": 81, + "execution_count": 316, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "(-0.017543645705293393, -0.011540115273533868)\n" + "(0.010924862357515821, -0.010644082225420766)\n" ] } ], "source": [ "%autoreload 2\n", - "\n", "import seaborn as sns\n", "from openproblems.tasks.regulatory_effect_prediction import metrics\n", - "\n", - "cors = metrics.spearman_correlation(adata_sample), metrics.pearson_correlation(adata_sample)\n", + "cors = metrics.spearman_correlation(adata), metrics.pearson_correlation(adata)\n", "print(cors)" ] + }, + { + "cell_type": "code", + "execution_count": 317, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: You’re trying to run this on 1233 dimensions of `.X`, if you really want this, set `use_rep='X'`.\n", + " Falling back to preprocessing with `sc.pp.pca` and default params.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(5081, 1233) (5081, 1233)\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'correlations')" + ] + }, + "execution_count": 317, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "sc.pp.neighbors(adata, n_neighbors=300)\n", + "adata.layers['X_knn'] = adata.obsp['connectivities'].dot(adata.X)\n", + "adata.layers['gene_score_knn'] = adata.obsp['connectivities'].dot(adata.obsm[\"gene_score\"])\n", + "print(adata.layers['X_knn'].shape, adata.layers['gene_score_knn'].shape)\n", + "from scipy.stats import pearsonr\n", + "cors = []\n", + "for i in range(adata.layers['X_knn'].shape[0]):\n", + " x = adata.layers['X_knn'][i,:]\n", + " y = adata.layers['gene_score_knn'][i,:].toarray().flatten()\n", + " cors.append(pearsonr(x, y))\n", + "cors_cor = list(map(lambda x: x[0], cors))\n", + "sns.kdeplot(np.array(list(cors_cor)))\n", + "plt.xlabel('correlations')" + ] } ], "metadata": { From 588ecb94e574d3b28d6f9d1b29f347035b783e9e Mon Sep 17 00:00:00 2001 From: ilibarra Date: Wed, 31 Mar 2021 16:37:15 +0200 Subject: [PATCH 6/7] updating functions to remove usage of local files... --- .../tests/snare_chrompotential_maestro.ipynb | 212 ++---------------- 1 file changed, 21 insertions(+), 191 deletions(-) diff --git a/openproblems/tasks/regulatory_effect_prediction/tests/snare_chrompotential_maestro.ipynb b/openproblems/tasks/regulatory_effect_prediction/tests/snare_chrompotential_maestro.ipynb index 8435144360..ca039608be 100644 --- a/openproblems/tasks/regulatory_effect_prediction/tests/snare_chrompotential_maestro.ipynb +++ b/openproblems/tasks/regulatory_effect_prediction/tests/snare_chrompotential_maestro.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 93, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -22,7 +22,7 @@ }, { "cell_type": "code", - "execution_count": 150, + "execution_count": 2, "metadata": { "jupyter": { "source_hidden": true @@ -179,7 +179,7 @@ }, { "cell_type": "code", - "execution_count": 216, + "execution_count": null, "metadata": { "tags": [] }, @@ -188,16 +188,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "obtaining annotation...\n", - "done...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "... storing 'chr' as categorical\n", - "... storing 'strand' as categorical\n" + "obtaining annotation...\n" ] } ], @@ -236,23 +227,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## II. Once an annotation has been prepared, we test the main approaches" + "## II. Once an annotation has been prepared, we test the main methods by just sampling the selected genes from before" ] }, { "cell_type": "code", - "execution_count": 287, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "before filtering (5081, 19322)\n", - "after filtering (5081, 1234)\n" - ] - } - ], + "outputs": [], "source": [ "# test = False does not work as tss_to_peaks need to be sub-sampled, and it seems that everything is blended.\n", "adata = datasets.snare_p0_braincortex(test=False)\n", @@ -270,65 +252,18 @@ }, { "cell_type": "code", - "execution_count": 231, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "... storing 'chr' as categorical\n", - "... storing 'strand' as categorical\n", - "/home/icb/ignacio.ibarra/miniconda3/envs/openproblems/lib/python3.7/site-packages/pandas/core/arrays/categorical.py:2487: FutureWarning: The `inplace` parameter in pandas.Categorical.remove_unused_categories is deprecated and will be removed in a future version.\n", - " res = method(*args, **kwargs)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "# weights calculated so far 500 out of 1232\n", - "# weights calculated so far 1000 out of 1232\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/mnt/znas/icb_zstore01/groups/ml01/workspace/ignacio.ibarra/SingleCellOpenProblems/openproblems/tasks/regulatory_effect_prediction/methods/maestro.py:63: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " \n" - ] - } - ], + "outputs": [], "source": [ "adata = methods.rp_simple(adata, n_top_genes=2000) # log_each=10)" ] }, { "cell_type": "code", - "execution_count": 291, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "ename": "KeyError", - "evalue": "'gene_score'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mseaborn\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0msns\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mopenproblems\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtasks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mregulatory_effect_prediction\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mmetrics\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mcors\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmetrics\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mspearman_correlation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0madata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetrics\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpearson_correlation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0madata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcors\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/mnt/znas/icb_zstore01/groups/ml01/workspace/ignacio.ibarra/SingleCellOpenProblems/openproblems/tools/decorators.py\u001b[0m in \u001b[0;36mapply_metric\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 107\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mapply_metric\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 108\u001b[0m \u001b[0mlog\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Running {} metric\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 109\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 110\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 111\u001b[0m apply_metric.metadata = dict(\n", - "\u001b[0;32m/mnt/znas/icb_zstore01/groups/ml01/workspace/ignacio.ibarra/SingleCellOpenProblems/openproblems/tasks/regulatory_effect_prediction/metrics/correlation.py\u001b[0m in \u001b[0;36mspearman_correlation\u001b[0;34m(adata)\u001b[0m\n\u001b[1;32m 39\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mmetric\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmetric_name\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"Median Spearman correlation\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmaximize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 40\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mspearman_correlation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0madata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 41\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0m_metric\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0madata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"spearman\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 42\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 43\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/mnt/znas/icb_zstore01/groups/ml01/workspace/ignacio.ibarra/SingleCellOpenProblems/openproblems/tasks/regulatory_effect_prediction/metrics/correlation.py\u001b[0m in \u001b[0;36m_metric\u001b[0;34m(adata, method)\u001b[0m\n\u001b[1;32m 19\u001b[0m x = (\n\u001b[1;32m 20\u001b[0m \u001b[0madata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mobsm\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"gene_score\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtoarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 21\u001b[0;31m \u001b[0;32mif\u001b[0m \u001b[0mscipy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msparse\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0missparse\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0madata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mobsm\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"gene_score\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 22\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0madata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mobsm\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"gene_score\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 23\u001b[0m )\n", - "\u001b[0;32m~/miniconda3/envs/openproblems/lib/python3.7/site-packages/anndata/_core/aligned_mapping.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 146\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 147\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__getitem__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mV\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 148\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 149\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 150\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__setitem__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mV\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mKeyError\u001b[0m: 'gene_score'" - ] - } - ], + "outputs": [], "source": [ "%autoreload 2\n", "import seaborn as sns\n", @@ -339,39 +274,9 @@ }, { "cell_type": "code", - "execution_count": 260, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(5081, 1233) (5081, 1233)\n" - ] - }, - { - "data": { - "text/plain": [ - "Text(0.5, 0, 'correlations')" - ] - }, - "execution_count": 260, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "\n", @@ -399,18 +304,9 @@ }, { "cell_type": "code", - "execution_count": 314, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "before filtering (5081, 19322)\n", - "after filtering (5081, 1234)\n" - ] - } - ], + "outputs": [], "source": [ "# test = False does not work as tss_to_peaks need to be sub-sampled, and it seems that everything is blended.\n", "adata = datasets.snare_p0_braincortex(test=False)\n", @@ -421,46 +317,18 @@ }, { "cell_type": "code", - "execution_count": 315, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "... storing 'chr' as categorical\n", - "... storing 'strand' as categorical\n", - "/home/icb/ignacio.ibarra/miniconda3/envs/openproblems/lib/python3.7/site-packages/pandas/core/arrays/categorical.py:2487: FutureWarning: The `inplace` parameter in pandas.Categorical.remove_unused_categories is deprecated and will be removed in a future version.\n", - " res = method(*args, **kwargs)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "calculating weights per gene...\n", - "# weights calculated so far 500 out of 1232\n", - "# weights calculated so far 1000 out of 1232\n" - ] - } - ], + "outputs": [], "source": [ "adata = methods.rp_enhanced(adata, n_top_genes=2000) # log_each=10)" ] }, { "cell_type": "code", - "execution_count": 316, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(0.010924862357515821, -0.010644082225420766)\n" - ] - } - ], + "outputs": [], "source": [ "%autoreload 2\n", "import seaborn as sns\n", @@ -471,47 +339,9 @@ }, { "cell_type": "code", - "execution_count": 317, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING: You’re trying to run this on 1233 dimensions of `.X`, if you really want this, set `use_rep='X'`.\n", - " Falling back to preprocessing with `sc.pp.pca` and default params.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(5081, 1233) (5081, 1233)\n" - ] - }, - { - "data": { - "text/plain": [ - "Text(0.5, 0, 'correlations')" - ] - }, - "execution_count": 317, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "\n", From 52b08b7750ac444ab2b92418d01892590a48d2b5 Mon Sep 17 00:00:00 2001 From: ilibarra Date: Wed, 31 Mar 2021 16:41:16 +0200 Subject: [PATCH 7/7] updating main notebook to write all plots --- .../tests/snare_chrompotential_maestro.ipynb | 206 ++++++++++++++++-- 1 file changed, 188 insertions(+), 18 deletions(-) diff --git a/openproblems/tasks/regulatory_effect_prediction/tests/snare_chrompotential_maestro.ipynb b/openproblems/tasks/regulatory_effect_prediction/tests/snare_chrompotential_maestro.ipynb index ca039608be..fb37fadad5 100644 --- a/openproblems/tasks/regulatory_effect_prediction/tests/snare_chrompotential_maestro.ipynb +++ b/openproblems/tasks/regulatory_effect_prediction/tests/snare_chrompotential_maestro.ipynb @@ -179,7 +179,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": { "tags": [] }, @@ -188,7 +188,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "obtaining annotation...\n" + "obtaining annotation...\n", + "done...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "... storing 'chr' as categorical\n", + "... storing 'strand' as categorical\n" ] } ], @@ -232,9 +241,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "before filtering (5081, 19322)\n", + "after filtering (5081, 1234)\n" + ] + } + ], "source": [ "# test = False does not work as tss_to_peaks need to be sub-sampled, and it seems that everything is blended.\n", "adata = datasets.snare_p0_braincortex(test=False)\n", @@ -252,18 +270,57 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "... storing 'chr' as categorical\n", + "... storing 'strand' as categorical\n", + "/home/icb/ignacio.ibarra/miniconda3/envs/openproblems/lib/python3.7/site-packages/pandas/core/arrays/categorical.py:2487: FutureWarning: The `inplace` parameter in pandas.Categorical.remove_unused_categories is deprecated and will be removed in a future version.\n", + " res = method(*args, **kwargs)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "# weights calculated so far 500 out of 1232\n", + "# weights calculated so far 1000 out of 1232\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/mnt/znas/icb_zstore01/groups/ml01/workspace/ignacio.ibarra/SingleCellOpenProblems/openproblems/tasks/regulatory_effect_prediction/methods/maestro.py:63: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " tss_to_peaks[\"weight\"] = weights\n" + ] + } + ], "source": [ "adata = methods.rp_simple(adata, n_top_genes=2000) # log_each=10)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(0.010924862357515821, -0.010644082225420766)\n" + ] + } + ], "source": [ "%autoreload 2\n", "import seaborn as sns\n", @@ -274,9 +331,47 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: You’re trying to run this on 1233 dimensions of `.X`, if you really want this, set `use_rep='X'`.\n", + " Falling back to preprocessing with `sc.pp.pca` and default params.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(5081, 1233) (5081, 1233)\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'correlations')" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.pyplot as plt\n", "\n", @@ -304,9 +399,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "before filtering (5081, 19322)\n", + "after filtering (5081, 1234)\n" + ] + } + ], "source": [ "# test = False does not work as tss_to_peaks need to be sub-sampled, and it seems that everything is blended.\n", "adata = datasets.snare_p0_braincortex(test=False)\n", @@ -317,18 +421,46 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "... storing 'chr' as categorical\n", + "... storing 'strand' as categorical\n", + "/home/icb/ignacio.ibarra/miniconda3/envs/openproblems/lib/python3.7/site-packages/pandas/core/arrays/categorical.py:2487: FutureWarning: The `inplace` parameter in pandas.Categorical.remove_unused_categories is deprecated and will be removed in a future version.\n", + " res = method(*args, **kwargs)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "calculating weights per gene...\n", + "# weights calculated so far 500 out of 1232\n", + "# weights calculated so far 1000 out of 1232\n" + ] + } + ], "source": [ "adata = methods.rp_enhanced(adata, n_top_genes=2000) # log_each=10)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(0.010924862357515821, -0.010644082225420766)\n" + ] + } + ], "source": [ "%autoreload 2\n", "import seaborn as sns\n", @@ -339,9 +471,47 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: You’re trying to run this on 1233 dimensions of `.X`, if you really want this, set `use_rep='X'`.\n", + " Falling back to preprocessing with `sc.pp.pca` and default params.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(5081, 1233) (5081, 1233)\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'correlations')" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.pyplot as plt\n", "\n",