diff --git a/runs.ipynb b/runs.ipynb index 5ef9f463..0809f447 100644 --- a/runs.ipynb +++ b/runs.ipynb @@ -61,7 +61,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -98,186 +98,694 @@ "datasets = ['op', 'replogle2', 'nakatake', 'norman', 'adamson']" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# new metric" - ] - }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "(8,)" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from src.metrics.wasserstein.script import main, par\n", - "output_dir = 'output'\n", - "datasets = ['adamson', 'norman']\n", - "models = ['pearson_corr', 'grnboost2','portia', 'ppcor','scenic']\n", - "n_maxs = [500, 1000, 5000, 10000, 50000]\n", - "\n", - "\n", - "# for dataset in datasets:\n", - "dataset = 'adamson'\n", - "par['evaluation_data'] = f'resources/datasets_raw/{dataset}_sc_counts.h5ad'\n", - "evaluation_data = ad.read_h5ad(par['evaluation_data'])\n", - "tf_all = np.loadtxt(par['tf_all'], dtype='str')\n", - "available_tfs = np.intersect1d(evaluation_data.obs['perturbation'].unique(), tf_all)\n", - "available_tfs.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "pearson_corr\n", - "grnboost2\n", - "portia\n", - "ppcor\n", - "scenic\n" - ] - } - ], - "source": [ - "n_edges_list = []\n", - "for model in models:\n", - " print(model)\n", - " try:\n", - " grn = pd.read_csv(f'resources/grn_models/{dataset}/{model}.csv')\n", - " except:\n", - " pass\n", - " n_edge = grn[grn['source'].isin(available_tfs)].shape[0]\n", - " n_edges_list.append(n_edge)" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "adamson\n", - "Remaining net size: (893, 4) TF size: 8 common TFs: (8,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 38%|███▊ | 3/8 [01:32<02:17, 27.44s/it]" - ] - } - ], - "source": [ - "print(dataset)\n", - "scores_all = []\n", - "for model in models:\n", - " par['evaluation_data'] = f'resources/datasets_raw/{dataset}_sc_counts.h5ad'\n", - " par['prediction'] = f'resources/grn_models/{dataset}/{model}.csv'\n", - " if not os.path.exists(par['prediction']):\n", - " print(f'Skip {dataset}-{model}')\n", - " continue\n", - " for n_max in [int(np.min(n_edges_list))]:\n", - " par['max_n_links'] = n_max\n", - " \n", - " _, wasserstein_distances, links = main(par)\n", - " for score, link in zip(wasserstein_distances, links):\n", - " scores_all.append({'model':model, 'n_max':n_max, 'link':link, 'score':score})\n", - "scores_all = pd.DataFrame(scores_all)\n", - "# scores_all.to_csv(f'{output_dir}/scores_{dataset}.csv')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "adamson_bulked.h5ad\tnorman_bulked.h5ad op_multiome_sc_counts.h5ad\n", - "adamson_sc_counts.h5ad\tnorman_sc_counts.h5ad op_perturbation_sc_counts.h5ad\n", - "nakatake_bulked.h5ad\top_bulked.h5ad\t replogle2_bulked.h5ad\n" - ] + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
  S1S2reg2-theta-0.0reg2-theta-0.5reg2-theta-1.0ws-theta-0.0ws-theta-0.5ws-theta-1.0
modeldataset        
negative_controlnakatake-0.000815-0.0009430.0005280.0360900.049519nannannan
positive_controlnakatake0.0005830.0016370.0476720.2283670.109110nannannan
pearson_corrnakatake0.0021030.0058360.0422620.2143510.097166nannannan
portianakatake-0.000014-0.0009000.0543150.1115420.074570nannannan
ppcornakatake0.0002360.0013670.0070700.0408840.051819nannannan
grnboost2nakatake-0.000561-0.0008690.0260390.2168810.153740nannannan
scenicnakatake0.0039150.0067970.0050720.0980200.096053nannannan
negative_controlnorman-0.007578-0.0077390.2269430.2254650.2211430.5345370.5081090.481342
positive_controlnorman-0.000811-0.0008440.4670820.2912450.2535760.8697710.7963150.635768
pearson_corrnorman0.0021220.0021600.4607780.2858920.2515860.7545530.7281150.608357
portianorman-0.002871-0.0029320.1779010.1683190.2026560.5316910.5466370.542537
ppcornorman-0.000423-0.0004320.3680730.2434920.2275290.6782370.6170600.528040
grnboost2norman-0.020135-0.0210260.4712990.2874000.2571200.8417190.8066410.706450
scenicnorman-0.005517-0.0162670.4174240.2373970.2235120.8237650.5600260.496490
negative_controladamson0.0223220.0223220.6034680.5876850.4220970.5071970.5080570.513410
positive_controladamson-0.008409-0.0106620.7260830.6393410.4454480.8499070.7887760.684532
pearson_corradamson0.0004030.0004970.7239720.6371750.4450360.8532800.8007400.669585
portiaadamson-0.003033-0.0031220.5157630.5282980.4098870.8007220.6729630.571839
ppcoradamson-0.000198-0.0002000.6629800.6117280.4324060.6517770.5613960.528788
grnboost2adamson-0.013015-0.0156180.7437070.6673630.4607090.8875590.8404260.730553
\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "!ls resources/datasets_raw" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "# adata = ad.read_h5ad('resources/datasets_raw/norman_sc_counts.h5ad')\n", - "\n", - "# sc.pp.normalize_total(adata)\n", - "# sc.pp.log1p(adata)" + "pd.read_csv('output/default_scores.csv', index_col=0).set_index(['model','dataset']).style.background_gradient()" ] }, { - "cell_type": "code", - "execution_count": 4, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "# tf = 'HOXA13'\n", - "# gene = 'MALAT1'\n", - "# mask_gene = adata.var_names==gene\n", - "# adata_ctr = adata[adata.obs['is_control']]\n", - "# adata_tf = adata[adata.obs['perturbation']==tf]\n", - "# print(adata_ctr.shape, adata_tf.shape)\n", - "\n", - "# for pert in adata_ctr.obs['perturbation'].unique():\n", - "# mask = adata_ctr.obs['perturbation']==pert\n", - "# X = adata_ctr[mask, :].X[:, mask_gene].todense().A.flatten()\n", - "\n", - "# plt.hist(X, label=pert, bins=100)\n", - "# X = adata_tf.X[:, mask_gene].todense().A.flatten()\n", - "# plt.hist(X, label=tf, bins=100)\n", - "# plt.legend()" + "# new metric" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 28, "metadata": {}, "outputs": [ { @@ -301,71 +809,65 @@ " \n", " \n", " \n", - " Unnamed: 0\n", - " model\n", - " n_max\n", - " link\n", - " score\n", - " dataset\n", " source\n", " target\n", + " ws_distance\n", + " ws_distance_pc\n", + " theta\n", + " dataset\n", + " model\n", " \n", " \n", " \n", " \n", - " 0\n", - " 0\n", + " 1008\n", + " BHLHE40\n", + " CMTM6\n", + " 0.226386\n", + " 0.960\n", + " theta-0.0\n", + " adamson\n", " pearson_corr\n", - " 500\n", - " AHR_CYP1A1\n", - " 0.054984\n", - " norman\n", - " AHR\n", - " CYP1A1\n", " \n", " \n", - " 1\n", - " 1\n", + " 1019\n", + " BHLHE40\n", + " CSRNP1\n", + " 0.018026\n", + " 0.528\n", + " theta-0.0\n", + " adamson\n", " pearson_corr\n", - " 500\n", - " AHR_AC005477.1\n", - " 0.033213\n", - " norman\n", - " AHR\n", - " AC005477.1\n", " \n", " \n", - " 2\n", - " 2\n", + " 1153\n", + " BHLHE40\n", + " ZBTB38\n", + " 0.163079\n", + " 0.916\n", + " theta-0.0\n", + " adamson\n", " pearson_corr\n", - " 500\n", - " AHR_CTTNBP2\n", - " 0.287646\n", - " norman\n", - " AHR\n", - " CTTNBP2\n", " \n", " \n", - " 3\n", - " 3\n", + " 1197\n", + " BHLHE40\n", + " TNFSF10\n", + " 0.053323\n", + " 0.628\n", + " theta-0.0\n", + " adamson\n", " pearson_corr\n", - " 500\n", - " AHR_RGS6\n", - " 0.068533\n", - " norman\n", - " AHR\n", - " RGS6\n", " \n", " \n", - " 4\n", - " 4\n", + " 1597\n", + " BHLHE40\n", + " EGR1\n", + " 0.089262\n", + " 0.737\n", + " theta-0.0\n", + " adamson\n", " pearson_corr\n", - " 500\n", - " CEBPA_CLC\n", - " 1.986679\n", - " norman\n", - " CEBPA\n", - " CLC\n", " \n", " \n", " ...\n", @@ -376,177 +878,315 @@ " ...\n", " ...\n", " ...\n", - " ...\n", " \n", " \n", - " 26666\n", - " 26666\n", - " ppcor\n", - " 50000\n", - " ZNF326_ALDH2\n", - " 0.103516\n", - " adamson\n", - " ZNF326\n", - " ALDH2\n", + " 1018\n", + " SPI1\n", + " SLC15A2\n", + " 0.002758\n", + " 0.654\n", + " theta-1.0\n", + " norman\n", + " scenic\n", " \n", " \n", - " 26667\n", - " 26667\n", - " ppcor\n", - " 50000\n", - " ZNF326_ZKSCAN1\n", - " 0.122790\n", - " adamson\n", - " ZNF326\n", - " ZKSCAN1\n", + " 4183\n", + " SPI1\n", + " HOXB4\n", + " 0.069025\n", + " 0.893\n", + " theta-1.0\n", + " norman\n", + " scenic\n", " \n", " \n", - " 26668\n", - " 26668\n", - " ppcor\n", - " 50000\n", - " ZNF326_STAC3\n", - " 0.060547\n", - " adamson\n", - " ZNF326\n", - " STAC3\n", + " 881\n", + " SPI1\n", + " RP11-266J6.2\n", + " 0.000387\n", + " 0.450\n", + " theta-1.0\n", + " norman\n", + " scenic\n", " \n", " \n", - " 26669\n", - " 26669\n", - " ppcor\n", - " 50000\n", - " ZNF326_AC002480.3\n", - " 0.000494\n", - " adamson\n", - " ZNF326\n", - " AC002480.3\n", + " 686\n", + " SPI1\n", + " AC108051.3\n", + " 0.000058\n", + " 0.263\n", + " theta-1.0\n", + " norman\n", + " scenic\n", " \n", " \n", - " 26670\n", - " 26670\n", - " ppcor\n", - " 50000\n", - " ZNF326_P2RX6\n", - " 0.003553\n", - " adamson\n", - " ZNF326\n", - " P2RX6\n", + " 2092\n", + " SPI1\n", + " RAI2\n", + " 0.000000\n", + " 0.000\n", + " theta-1.0\n", + " norman\n", + " scenic\n", " \n", " \n", "\n", - "

113399 rows × 8 columns

\n", + "

117897 rows × 7 columns

\n", "" ], "text/plain": [ - " Unnamed: 0 model n_max link score dataset \\\n", - "0 0 pearson_corr 500 AHR_CYP1A1 0.054984 norman \n", - "1 1 pearson_corr 500 AHR_AC005477.1 0.033213 norman \n", - "2 2 pearson_corr 500 AHR_CTTNBP2 0.287646 norman \n", - "3 3 pearson_corr 500 AHR_RGS6 0.068533 norman \n", - "4 4 pearson_corr 500 CEBPA_CLC 1.986679 norman \n", - "... ... ... ... ... ... ... \n", - "26666 26666 ppcor 50000 ZNF326_ALDH2 0.103516 adamson \n", - "26667 26667 ppcor 50000 ZNF326_ZKSCAN1 0.122790 adamson \n", - "26668 26668 ppcor 50000 ZNF326_STAC3 0.060547 adamson \n", - "26669 26669 ppcor 50000 ZNF326_AC002480.3 0.000494 adamson \n", - "26670 26670 ppcor 50000 ZNF326_P2RX6 0.003553 adamson \n", + " source target ws_distance ws_distance_pc theta dataset \\\n", + "1008 BHLHE40 CMTM6 0.226386 0.960 theta-0.0 adamson \n", + "1019 BHLHE40 CSRNP1 0.018026 0.528 theta-0.0 adamson \n", + "1153 BHLHE40 ZBTB38 0.163079 0.916 theta-0.0 adamson \n", + "1197 BHLHE40 TNFSF10 0.053323 0.628 theta-0.0 adamson \n", + "1597 BHLHE40 EGR1 0.089262 0.737 theta-0.0 adamson \n", + "... ... ... ... ... ... ... \n", + "1018 SPI1 SLC15A2 0.002758 0.654 theta-1.0 norman \n", + "4183 SPI1 HOXB4 0.069025 0.893 theta-1.0 norman \n", + "881 SPI1 RP11-266J6.2 0.000387 0.450 theta-1.0 norman \n", + "686 SPI1 AC108051.3 0.000058 0.263 theta-1.0 norman \n", + "2092 SPI1 RAI2 0.000000 0.000 theta-1.0 norman \n", "\n", - " source target \n", - "0 AHR CYP1A1 \n", - "1 AHR AC005477.1 \n", - "2 AHR CTTNBP2 \n", - "3 AHR RGS6 \n", - "4 CEBPA CLC \n", - "... ... ... \n", - "26666 ZNF326 ALDH2 \n", - "26667 ZNF326 ZKSCAN1 \n", - "26668 ZNF326 STAC3 \n", - "26669 ZNF326 AC002480.3 \n", - "26670 ZNF326 P2RX6 \n", + " model \n", + "1008 pearson_corr \n", + "1019 pearson_corr \n", + "1153 pearson_corr \n", + "1197 pearson_corr \n", + "1597 pearson_corr \n", + "... ... \n", + "1018 scenic \n", + "4183 scenic \n", + "881 scenic \n", + "686 scenic \n", + "2092 scenic \n", "\n", - "[113399 rows x 8 columns]" + "[117897 rows x 7 columns]" ] }, - "execution_count": 3, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "scores_all = []\n", - "for dataset in ['norman','adamson']:\n", - " scores = pd.read_csv(f'output/scores_{dataset}.csv')\n", - " scores['dataset'] = dataset\n", - " scores_all.append(scores)\n", - "scores_all = pd.concat(scores_all)\n", - "scores_all[['source','target']]=[item.split('_')[0:2] for item in scores_all['link']]\n", + "scores_all = pd.read_csv('resources/scores/ws_distance.csv', index_col=0)\n", "scores_all" ] }, { "cell_type": "code", - "execution_count": 40, - "metadata": {}, - "outputs": [], - "source": [ - "n_maxs = [500,1000]\n", - "scores_all = scores_all[scores_all['n_max'].isin(n_maxs)]" - ] - }, - { - "cell_type": "code", - "execution_count": 6, + "execution_count": 25, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
  theta-0.0theta-0.5theta-1.0
modeldataset   
pearson_corradamson0.8716730.7893110.679417
grnboost2adamson0.8904460.8482080.750937
portiaadamson0.7983030.6824590.573197
ppcoradamson0.6523540.5656450.536111
pearson_corrnorman0.7690070.7126580.607553
grnboost2norman0.8474570.7931540.704702
portianorman0.5534820.5631310.546728
ppcornorman0.6941570.6376540.532154
scenicnorman0.8902690.5869510.513064
\n" + ], "text/plain": [ - "
" + "" ] }, + "execution_count": 25, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" } ], "source": [ - "import seaborn as sns\n", + "mean_scores_all = pd.read_csv('resources/scores/ws_distance_mean.csv', index_col=0).set_index(['model', 'dataset'])\n", "\n", - "# Plot heatmap\n", - "for dataset in scores_all['dataset'].unique():\n", - " scores = scores_all[scores_all['dataset']==dataset]\n", - " heatmap_data = (\n", - " scores.groupby([\"model\", \"n_max\"])[\"score\"]\n", - " .median() # Aggregate scores (mean or other metric)\n", - " .unstack() # Reshape for heatmap\n", - " )\n", - " plt.figure(figsize=(4, 3))\n", - " sns.heatmap(heatmap_data, annot=True, fmt=\".2f\", cmap=\"coolwarm\")\n", - " plt.xlabel(\"n_max\")\n", - " plt.show()" + "mean_scores_all.style.background_gradient()" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 32, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", "text/plain": [ - "
" + "" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" ] }, "metadata": {}, @@ -560,73 +1200,18 @@ "# Example: FacetGrid Line Plot\n", "g = sns.catplot(\n", " data=scores_all,\n", - " kind=\"bar\",\n", + " kind=\"strip\",\n", " x=\"model\",\n", - " y=\"score\",\n", + " y=\"ws_distance_pc\",\n", " hue='dataset',\n", - " col=\"n_max\", \n", + " col=\"theta\", \n", " height=4, \n", " aspect=1 \n", ")\n", "g.fig.tight_layout() # Adjust layout to fit everything\n", "g.set_xticklabels(rotation=45, ha='right')\n", - "for ax in g.axes.flat:\n", - " ax.set_yscale('log')" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "scores_all = scores_all[scores_all.model.isin(['grnboost2','ppcor'])]" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "n_max model \n", - "500 grnboost2 1000\n", - " pearson_corr 1000\n", - " portia 1000\n", - " ppcor 1000\n", - " scenic 500\n", - "1000 grnboost2 2000\n", - " pearson_corr 2000\n", - " portia 2000\n", - " ppcor 1893\n", - " scenic 944\n", - "5000 grnboost2 7908\n", - " pearson_corr 7073\n", - " portia 6052\n", - " ppcor 5893\n", - " scenic 944\n", - "10000 grnboost2 12282\n", - " pearson_corr 9023\n", - " portia 7921\n", - " ppcor 5926\n", - " scenic 944\n", - "50000 grnboost2 12282\n", - " pearson_corr 9023\n", - " portia 7921\n", - " ppcor 5926\n", - " scenic 944\n", - "dtype: int64" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "scores_all.groupby(['n_max','model']).size()" + "# for ax in g.axes.flat:\n", + "# ax.set_yscale('log')" ] }, { diff --git a/scripts/sbatch/calculate_scores.sh b/scripts/sbatch/calculate_scores.sh index 9533028d..55f53d59 100644 --- a/scripts/sbatch/calculate_scores.sh +++ b/scripts/sbatch/calculate_scores.sh @@ -1,11 +1,12 @@ #!/bin/bash #SBATCH --job-name=scores -#SBATCH --time=48:00:00 +#SBATCH --time=10:00:00 #SBATCH --output=logs/%j.out #SBATCH --error=logs/%j.err #SBATCH --mail-type=END #SBATCH --mail-user=jalil.nourisa@gmail.com #SBATCH --mem=64G -#SBATCH --cpus-per-task=20 +#SBATCH --cpus-per-task=1 -python src/metrics/script_all.py +# python src/metrics/script_all.py +python src/metrics/all_metrics/script_all.py diff --git a/scripts/sbatch/run_helper.sh b/scripts/sbatch/run_helper.sh index 49fa4c36..767840dc 100644 --- a/scripts/sbatch/run_helper.sh +++ b/scripts/sbatch/run_helper.sh @@ -8,4 +8,5 @@ #SBATCH --mem=64G #SBATCH --cpus-per-task=20 -python src/helper.py +# python src/helper.py +python src/metrics/wasserstein/background_score.py diff --git a/src/api/comp_metric.yaml b/src/api/comp_metric.yaml index 67d45531..f5f497c6 100644 --- a/src/api/comp_metric.yaml +++ b/src/api/comp_metric.yaml @@ -70,6 +70,12 @@ functionality: type: boolean direction: input default: false + - name: --dataset_id + type: string + direction: input + required: true + default: op + test_resources: - type: python_script diff --git a/src/methods/script_all.py b/src/methods/script_all.py index e9db0062..a7b64184 100644 --- a/src/methods/script_all.py +++ b/src/methods/script_all.py @@ -115,6 +115,9 @@ def run_grn_inference(dataset='op', subsample=None): elif method in ["scenicplus"]: mem = "250GB" time = "12:00:00" + elif method in ["scenic"]: + mem = "250GB" + time = "24:00:00" # Prepare sbatch command tag = f"--job-name={method}" # No spaces around '=' @@ -143,23 +146,24 @@ def run_grn_inference(dataset='op', subsample=None): print(f"Command error output: {e.stderr}") if __name__ == '__main__': - force = False + force = True sbatch = True # methods = ["positive_control", "negative_control", "pearson_corr", "portia", "grnboost2", "ppcor", "scenic"], # methods = ["portia", "grnboost2"] - methods = ["scenicplus"] + methods = ["scenic"] + datasets = ['adamson'] partition='cpu' - mem = "120GB" - time = "12:00:00" + # mem = "120GB" + # time = "24:00:00" - if False: # normal run - for dataset in ['op','replogle2', 'norman', 'adamson', 'nakatake']: + if True: # normal run + for dataset in datasets: run_grn_inference(dataset, subsample=None) - if True: # subsample + if False: # subsample # for dataset in ['replogle2', 'norman', 'adamson', 'nakatake']: # 'replogle2' 'op' norman for dataset in ['op']: if dataset == 'op': diff --git a/src/metrics/all_metrics/helper.py b/src/metrics/all_metrics/helper.py new file mode 100644 index 00000000..65e975dd --- /dev/null +++ b/src/metrics/all_metrics/helper.py @@ -0,0 +1,66 @@ +import os +import pandas as pd +from regression_2.consensus.script import main as main_consensus_reg2 +from wasserstein.consensus.script import main as main_consensus_ws +from wasserstein.background_distance.script import main as main_ws_background_distance +from all_metrics.script import main as main_scores +from all_metrics.script import par as main_par + + + +def run_scores_all(datasets, models): + scores_dir = 'resources/scores/' + save_file_name = f"{scores_dir}/default_scores.csv" + + scores_store = [] + for dataset in datasets: + for model in models: + par = main_par.copy() + # - adjust par + par['dataset_id'] = dataset + par['prediction'] = f'resources/grn_models/{dataset}/{model}.csv' + if not os.path.exists(par['prediction']): + print('Skipping ', par['prediction']) + continue + # - run + scores_model = main_scores(par) + scores_model['model'] = model + scores_model['dataset'] = dataset + + scores_store.append(scores_model) + scores_all = pd.concat(scores_store) + scores_all.to_csv(save_file_name) + +def run_consensus(datasets): + models = ['positive_control', 'pearson_corr', 'portia', 'ppcor', 'grnboost2', 'scenic', 'granie', 'scglue', 'celloracle', 'figr', 'scenicplus'] + + for dataset in datasets: + par = { + 'models': models, + 'evaluation_data': f'resources/evaluation_datasets/{dataset}_perturbation.h5ad', + 'evaluation_data_sc': f'resources/datasets_raw/{dataset}_sc_counts.h5ad', + 'models_dir': f'resources/grn_models/{dataset}/', + 'regulators_consensus': f'resources/prior/regulators_consensus_{dataset}.json', + 'ws_consensus': f'resources/prior/ws_consensus_{dataset}.csv', + 'tf_all': 'resources/prior/tf_all.csv', + + } + # - reg2 consensus + print(f'--determining consensus for reg2--{dataset}') + main_consensus_reg2(par) + + # - ws consensus + print(f'--determining consensus for ws--{dataset}') + if dataset in ['norman', 'adamson']: + main_consensus_ws(par) +def run_ws_distance_background(datasets): + for dataset in datasets: + par = { + 'evaluation_data_sc': f'resources/datasets_raw/{dataset}_sc_counts.h5ad', + 'background_distance': f'resources/prior/ws_distance_background_{dataset}.csv', + 'tf_all': 'resources/prior/tf_all.csv', + 'layer': 'X_norm' + } + print(f'--run ws distance background --{dataset}') + if dataset in ['norman', 'adamson']: + main_ws_background_distance(par) diff --git a/src/metrics/all_metrics/script.py b/src/metrics/all_metrics/script.py new file mode 100644 index 00000000..440175fc --- /dev/null +++ b/src/metrics/all_metrics/script.py @@ -0,0 +1,82 @@ +import pandas as pd +import anndata as ad +import sys +import numpy as np +import os + + +## VIASH START +par = { + 'prediction': f'resources/grn_models/norman/grnboost2.csv', + 'method_id': 'grnboost2', + + "tf_all": f"resources/prior/tf_all.csv", + 'skeleton': f'resources/prior/skeleton.csv', + 'dataset_id': 'norman', + 'layer': 'X_norm', + "apply_tf": True, + 'subsample': -1, + 'verbose': 4, + 'num_workers': 20, + 'binarize': False, + 'max_n_links': 50000, + 'apply_skeleton': False, + 'reg_type':'ridge', + 'score': 'output/score.h5ad' +} +## VIASH END + +meta = { + "resources_dir": 'src/metrics/', + "util": 'src/utils' +} +sys.path.append(meta["resources_dir"]) +sys.path.append(meta["util"]) +from regression_1.main import main as main_reg1 +from regression_2.main import main as main_reg2 +from wasserstein.script import main as main_ws + + + +def main(par): + """ + Calculate all scores for a given model and daatset. + """ + assert par['dataset_id'] + dataset = par['dataset_id'] + + par['evaluation_data'] = f'resources/evaluation_datasets/{dataset}_perturbation.h5ad' + par['evaluation_data_sc'] = f'resources/datasets_raw/{dataset}_sc_counts.h5ad' + par['regulators_consensus'] = f'resources/prior/regulators_consensus_{dataset}.json' + par['ws_consensus'] = f'resources/prior/ws_consensus_{dataset}.csv' + par['ws_distance_background'] = f'resources/prior/ws_distance_background_{dataset}.csv' + + scores_all = [] + + scores_reg1 = main_reg1(par) + scores_all.append(scores_reg1) + scores_reg2 = main_reg2(par) + scores_all.append(scores_reg2) + if dataset in ['norman', 'adamson']: + print(par) + _, scores_ws = main_ws(par) + scores_all.append(scores_ws) + + scores_all = pd.concat(scores_all, axis=1) + + return scores_all +if __name__ == '__main__': + scores_all = main(par) + + output = ad.AnnData( + X=np.empty((0, 0)), + uns={ + "dataset_id": par["dataset_id"], + "method_id": par['method_id'], + "metric_ids": scores_all.columns.values, + "metric_values": scores_all.values[0] + } + ) + print(output) + output.write_h5ad(par['score'], compression='gzip') + print('Completed', flush=True) diff --git a/src/metrics/all_metrics/script_all.py b/src/metrics/all_metrics/script_all.py new file mode 100644 index 00000000..cb44dacd --- /dev/null +++ b/src/metrics/all_metrics/script_all.py @@ -0,0 +1,162 @@ +import pandas as pd +import anndata as ad +import sys +import numpy as np +import os + +meta = { + "resources_dir": 'src/metrics/', + "util": 'src/utils' +} +sys.path.append(meta["resources_dir"]) +sys.path.append(meta["util"]) + +from all_metrics.helper import run_consensus, run_ws_distance_background, run_scores_all + +par = { + 'layer': 'X_norm', + "tf_all": "resources/prior/tf_all.csv", + 'skeleton': 'resources/prior/skeleton.csv', + "apply_tf": True, + 'subsample': -1, + 'verbose': 4, + 'num_workers': 20, + 'binarize': False, + 'max_n_links': 50000, + 'apply_skeleton': False, + 'reg_type':'ridge' + } + + +def run_evaluation(dataset, models, models_dir, save_file_name): + print('------ ', dataset, '------') + + # - determines models to run + grn_files_dict = {} + # - add models + for model in models: + print(model) + grn_file = f"{models_dir}/{model}.csv" + if not os.path.exists(grn_file): + print(f"{grn_file} doesnt exist. Skipped.") + continue + grn_files_dict[model] = grn_file + + # - actual runs + i = 0 + for model, grn_file in grn_files_dict.items(): + par['prediction'] = grn_file + reg1 = main_reg1(par) + reg2 = main_reg2(par) + score = pd.concat([reg1, reg2], axis=1) + score.index = [model] + if i==0: + df_all = score + else: + df_all = pd.concat([df_all, score]) + df_all.to_csv(save_file_name) + print(df_all) + i+=1 + +if __name__ == '__main__': + run_scores_flag = True + run_consensus_flag = False + run_ws_distance_background_flag = False + datasets = ['op', 'replogle2', 'nakatake', 'norman', 'adamson'] + + if run_consensus_flag: # run consensus + run_consensus(datasets) + + if run_ws_distance_background_flag: # run background scores for ws distance + run_ws_distance_background(datasets) + + if run_scores_flag: + models = ['negative_control', 'positive_control', 'pearson_corr', 'portia', 'ppcor', 'grnboost2', 'scenic', 'granie', 'scglue', 'celloracle', 'figr', 'scenicplus'] + + run_scores_all(datasets, models=models) + + + aaa + + if False: # default run + for dataset in dataset: + models_dir = f"resources/grn_models/{dataset}" + scores_dir = f"resources/scores/{dataset}" + run_consensus(dataset) + save_file_name = f"{scores_dir}/default_scores.csv" + + run_evaluation(dataset, models, models_dir, scores_dir, save_file_name) + + if True: # subsample + # for dataset in ['op', 'replogle2', 'nakatake', 'norman', 'adamson']: #'op', 'replogle2', 'nakatake', 'norman', 'adamson' + for dataset in ['op']: + if dataset == 'op': + models_subsampled = [f'{model}_{subsample}' for subsample in [1, 2] for model in models] + else: + models_subsampled = [f'{model}_{subsample}' for subsample in [0.2, 0.5] for model in models] + models_dir = f"resources/grn_models/{dataset}" + scores_dir = f"resources/scores/{dataset}" + + save_file_name = f"{scores_dir}/subsampled.csv" + + run_evaluation(dataset, models_subsampled, models_dir, scores_dir, save_file_name) + + + + if False: # run global models + models = ['pearson_corr'] + dataset = 'op' + + models_dir = "resources/grn_models/global/" + scores_dir = f"resources/scores/{dataset}" + # run_consensus(dataset) + save_file_name = f"{scores_dir}/X_norm-50000-skeleton_False-binarize_False-ridge-global-True.csv" + + run_evaluation(dataset, models, models_dir, scores_dir, run_global_models, save_file_name) + + if False: # run skeleton + models = ['negative_control', 'positive_control', 'pearson_corr', 'portia', 'ppcor', 'grnboost2', 'scenic', 'granie', 'scglue', 'celloracle', 'figr', 'scenicplus'] + + dataset = 'op' + + models_dir = f"resources/grn_models/{dataset}" + scores_dir = f"resources/scores/{dataset}" + save_file_name = f"{scores_dir}/X_norm-50000-skeleton_True-binarize_False-ridge-global-False.csv" + + # run_consensus(dataset) + run_evaluation(dataset, models, models_dir, scores_dir, save_file_name, apply_skeleton=True) + + if False: # run GB + models = ['negative_control', 'positive_control', 'pearson_corr', 'portia', 'ppcor', 'grnboost2', 'scenic', 'granie', 'scglue', 'celloracle', 'figr', 'scenicplus'] + + dataset = 'op' + + models_dir = f"resources/grn_models/{dataset}" + scores_dir = f"resources/scores/{dataset}" + save_file_name = f"{scores_dir}/X_norm-50000-skeleton_True-binarize_False-GB-global-False.csv" + + # run_consensus(dataset) + run_evaluation(dataset, models, models_dir, scores_dir, save_file_name, apply_skeleton=True, reg_type='GB') + + + + + + +# def define_par(dataset): + +# par = { +# "evaluation_data": f"resources/evaluation_datasets/{dataset}_perturbation.h5ad", +# 'consensus': f'resources/prior/{dataset}_consensus-num-regulators.json', + +# 'layer': 'X_norm', + +# "tf_all": "resources/prior/tf_all.csv", +# 'skeleton': 'resources/prior/skeleton.csv', +# "apply_tf": True, +# 'subsample': -1, +# 'verbose': 4, +# 'num_workers': 20 +# } + +# return par diff --git a/src/metrics/consensus/create-consensus.sh b/src/metrics/consensus/create-consensus.sh deleted file mode 100644 index e5a9c252..00000000 --- a/src/metrics/consensus/create-consensus.sh +++ /dev/null @@ -1,4 +0,0 @@ -viash run src/metrics/regression_2/consensus/config.novsh.yaml -- --perturbation_data resources/grn-benchmark/perturbation_data.h5ad \ - --output resources/prior/consensus-num-regulators.json \ - --grn_folder resources/grn_models/ \ - --grns ananse.csv,celloracle.csv,figr.csv,granie.csv,scenicplus.csv,scglue.csv \ No newline at end of file diff --git a/src/metrics/regression_1/script.py b/src/metrics/regression_1/script.py index 3086d3c6..18f0cd2d 100644 --- a/src/metrics/regression_1/script.py +++ b/src/metrics/regression_1/script.py @@ -77,7 +77,7 @@ output = ad.AnnData( X=np.empty((0, 0)), uns={ - "dataset_id": par["layer"], + "dataset_id": par["dataset_id"], "method_id": f"reg1-{par['method_id']}", "metric_ids": metric_ids, "metric_values": metric_values diff --git a/src/metrics/consensus/config.novsh.yaml b/src/metrics/regression_2/consensus/config.novsh.yaml similarity index 100% rename from src/metrics/consensus/config.novsh.yaml rename to src/metrics/regression_2/consensus/config.novsh.yaml diff --git a/src/metrics/consensus/script.py b/src/metrics/regression_2/consensus/script.py similarity index 81% rename from src/metrics/consensus/script.py rename to src/metrics/regression_2/consensus/script.py index b378a4c0..465b4f2d 100644 --- a/src/metrics/consensus/script.py +++ b/src/metrics/regression_2/consensus/script.py @@ -10,10 +10,10 @@ ## VIASH START par = { - 'evaluation_data': 'resources/grn-benchmark/evaluation_data.h5ad', - # 'models_dir': 'resources/grn-benchmark/grn_models/d0_hvg', - # 'models': [pearson_corr, pearson_causal, portia, ppcor, genie3, grnboost2, scenic, scglue, celloracle], - 'consensus': 'resources/prior/consensus-num-regulators.json' + 'evaluation_data': 'resources/evaluation_datasets/op_perturbation.h5ad', + 'models_dir': 'resources/grn_models/op/', + 'models': ['pearson_corr', 'pearson_causal', 'portia', 'ppcor', 'genie3', 'grnboost2', 'scenic', 'scglue', 'celloracle'], + 'regulators_consensus': 'resources/prior/regulators_consensus_op.json' } ## VIASH END def main(par): @@ -57,8 +57,10 @@ def main(par): results = {} for i, gene_name in enumerate(gene_names): results[gene_name] = {theta: int(n_tfs[theta][i]) for theta in thetas} - with open(par['consensus'], 'w') as f: + with open(par['regulators_consensus'], 'w') as f: json.dump(results, f) + + return results if __name__ == '__main__': diff --git a/src/metrics/regression_2/main.py b/src/metrics/regression_2/main.py index d7959eaa..52f825f3 100644 --- a/src/metrics/regression_2/main.py +++ b/src/metrics/regression_2/main.py @@ -312,7 +312,7 @@ def main(par: Dict[str, Any]) -> pd.DataFrame: X = RobustScaler().fit_transform(X) # Load consensus numbers of putative regulators - with open(par['consensus'], 'r') as f: + with open(par['regulators_consensus'], 'r') as f: data = json.load(f) gene_names_ = np.asarray(list(data.keys()), dtype=object) @@ -338,9 +338,9 @@ def main(par: Dict[str, Any]) -> pd.DataFrame: score_static_max = static_approach(net_matrix, n_features_theta_max, X, groups, gene_names, tf_names, par['reg_type'], n_jobs=par['num_workers']) results = { - 'static-theta-0.0': [float(score_static_min)], - 'static-theta-0.5': [float(score_static_median)], - 'static-theta-1.0': [float(score_static_max)], + 'reg2-theta-0.0': [float(score_static_min)], + 'reg2-theta-0.5': [float(score_static_median)], + 'reg2-theta-1.0': [float(score_static_max)], } # # Add dynamic score diff --git a/src/metrics/regression_2/script.py b/src/metrics/regression_2/script.py index 6d55d22e..2d906769 100644 --- a/src/metrics/regression_2/script.py +++ b/src/metrics/regression_2/script.py @@ -52,7 +52,7 @@ output = ad.AnnData( X=np.empty((0, 0)), uns={ - "dataset_id": str(par["layer"]), + "dataset_id": str(par["dataset_id"]), "method_id": f"reg2-{par['method_id']}", "metric_ids": metric_ids, "metric_values": metric_values diff --git a/src/metrics/script_all.py b/src/metrics/script_all_experiment.py similarity index 100% rename from src/metrics/script_all.py rename to src/metrics/script_all_experiment.py diff --git a/src/metrics/wasserstein/background_distance/script.py b/src/metrics/wasserstein/background_distance/script.py new file mode 100644 index 00000000..674808f4 --- /dev/null +++ b/src/metrics/wasserstein/background_distance/script.py @@ -0,0 +1,69 @@ +import anndata as ad +from tqdm import tqdm +import sys +import scipy +import pandas as pd +import numpy as np + + + +# - create background dist. +par = { + 'evaluation_data_sc': f'resources/datasets_raw/norman_sc_counts.h5ad', + 'background_distance': 'resources/prior/ws_distance_background_norman.csv', + 'tf_all': 'resources/prior/tf_all.csv', + 'layer': 'X_norm' +} + + +def calculate_ws_distance(net, adata) -> pd.DataFrame: + """ + Get a net with source and target columns, and adata with gene expression data for control and interventaion, + and returns the net with added column of wasserstein distance. + """ + gene_names = adata.var_names + ws_distances = [] + + for parent, child in zip(net['source'],net['target']): + # - get observational X + mask_gene = gene_names==child + mask_sample = adata.obs['is_control'] + X_observ = adata[mask_sample, mask_gene].X.todense().A + # - get interventional + mask_gene = gene_names==child + assert parent in adata.obs['perturbation'].unique() + mask_sample = adata.obs['perturbation']==parent + X_interv = adata[mask_sample, mask_gene].X.todense().A + + assert X_observ.shape[0] != 0 + assert X_interv.shape[0] != 0 + + # - calculate the distance + ws_distance = scipy.stats.wasserstein_distance( + X_observ.reshape(-1), X_interv.reshape(-1) + ) + ws_distances.append(ws_distance) + net['ws_distance'] = ws_distances + return net + + +def main(par): + adata = ad.read_h5ad(par['evaluation_data_sc']) + adata.X = adata.layers[par['layer']] + + tf_all = np.loadtxt(par['tf_all'], dtype='str') + available_tfs = np.intersect1d(adata.obs['perturbation'].unique(), tf_all) + + # - for each tf, select a random background net and calculate the distances + + random_grn_store = [] + for tf in tqdm(available_tfs): + # random_genes = np.random.choice(adata.var_names, par['n_selection'], replace=False) + random_grn = pd.DataFrame([{'source':tf, 'target': gene} for gene in adata.var_names]) + + random_grn = calculate_ws_distance(random_grn, adata) + random_grn_store.append(random_grn) + random_grn_ws_distance = pd.concat(random_grn_store) + random_grn_ws_distance.to_csv(par['background_distance']) +if __name__ == '__main__': + main(par) \ No newline at end of file diff --git a/src/metrics/wasserstein/consensus/script.py b/src/metrics/wasserstein/consensus/script.py new file mode 100644 index 00000000..c21392f4 --- /dev/null +++ b/src/metrics/wasserstein/consensus/script.py @@ -0,0 +1,55 @@ +import pandas as pd +import anndata as ad +from tqdm import tqdm +import numpy as np +import os + +# - determine consensus +par = { + 'evaluation_data_sc': f'resources/datasets_raw/norman_sc_counts.h5ad', + 'ws_consensus': 'resources/prior/consensus_ws_distance_norman.csv', + 'tf_all': 'resources/prior/tf_all.csv', + 'models_dir': 'resources/grn_models/norman', + 'models': ['pearson_corr', 'grnboost2','portia', 'ppcor','scenic'] +} +def main(par): + + adata = ad.read_h5ad(par['evaluation_data_sc']) + tf_all = np.loadtxt(par['tf_all'], dtype='str') + available_tfs = np.intersect1d(adata.obs['perturbation'].unique(), tf_all) + + # - read all models + grn_store = [] + for model in par['models']: + prediction_file = f"{par['models_dir']}/{model}.csv" + if not os.path.exists(prediction_file): + print(prediction_file, ' doesnt exists') + continue + else: + grn = pd.read_csv(prediction_file, index_col=0) + + grn['model'] = model + grn_store.append(grn) + grn_all = pd.concat(grn_store).reset_index(drop=True) + # print(grn_all) + + # - subset to available TFs + grn_all = grn_all[grn_all['source'].isin(available_tfs)] + + # - determine consensus + edges_count = grn_all.groupby(['source', 'model']).size().reset_index(name='n_edges').pivot(index='source',columns='model').fillna(0) + + consensus = [] + for tf, row in edges_count.iterrows(): + row_nozero = row[row!=0] + consensus.append({'source':tf, 'theta':'ws-theta-0.0', 'value':int(np.quantile(row_nozero, 0))}) + consensus.append({'source':tf, 'theta':'ws-theta-0.5', 'value':int(np.quantile(row_nozero, 0.5))}) + consensus.append({'source':tf, 'theta':'ws-theta-1.0', 'value':int(np.quantile(row_nozero, 1))}) + consensus = pd.DataFrame(consensus) + # - save + consensus.to_csv(par['ws_consensus']) + + return consensus + +if __name__ == '__main__': + main(par) \ No newline at end of file diff --git a/src/metrics/wasserstein/script.py b/src/metrics/wasserstein/script.py index f7f2c6b7..f4693768 100644 --- a/src/metrics/wasserstein/script.py +++ b/src/metrics/wasserstein/script.py @@ -1,126 +1,71 @@ -import os -import json - -import anndata import pandas as pd import anndata as ad import sys import numpy as np -import scipy -import random -from tqdm import tqdm -import scanpy as sc + ## VIASH START par = { - 'evaluation_data': 'resources/datasets_raw/norman_sc_counts.h5ad', - 'prediction': 'resources/grn_models/norman/grnboost2.csv', - 'tf_all': 'resources/prior/tf_all.csv', - 'max_n_links': 50_000 + 'prediction': 'resources/grn_models/adamson/pearson_corr.csv', + 'evaluation_data_sc': 'resources/datasets_raw/adamson_sc_counts.h5ad', + 'output_file': 'resources/prior/ws_distance_background.csv', + 'score': 'output/score.h5ad', + 'ws_consensus': 'resources/prior/consensus_ws_distance_adamson.csv', + 'ws_distance_background':'resources/prior/ws_distance_background_adamson.csv', + 'layer': 'X_norm', + 'dataset_id': 'dataset_id', + 'method_id': 'pearson_corr' } ## VIASH END def main(par): - - def get_observational(child: str) -> np.array: - """ - Return all the samples for gene "child" in cells where there was no perturbations - - - Args: - child: Gene name of child to get samples for - - Returns: - np.array matrix of corresponding samples - """ - mask_gene = gene_names==child - mask_sample = adata_rna.obs['is_control'] - - X = adata_rna[mask_sample, mask_gene].X.todense().A - - return X - - def get_interventional(child: str, parent: str) -> np.array: - """ - Return all the samples for gene "child" in cells where "parent" was perturbed - - Args: - child: Gene name of child to get samples for - parent: Gene name of gene that must have been perturbed - - Returns: - np.array matrix of corresponding samples - """ - mask_gene = gene_names==child - assert parent in adata_rna.obs['perturbation'].unique() - - - mask_sample = adata_rna.obs['perturbation']==parent - # print(mask_sample.sum()) - - X = adata_rna[mask_sample, mask_gene].X.todense().A - return X - # - read adata and normalize - adata_rna = anndata.read_h5ad(par['evaluation_data']) - sc.pp.normalize_total(adata_rna) - sc.pp.log1p(adata_rna) - gene_names = adata_rna.var_names - - # - read the net and retain only those tfs that are mutually available in both adata perturbation and net - net = pd.read_csv(par['prediction']) - tfs_pertubed = adata_rna[~adata_rna.obs['is_control']].obs['perturbation'].unique() - tfs_common = np.intersect1d(tfs_pertubed, net['source'].unique()) - - net = net[net['source'].isin(tfs_common)] - net = net.nlargest(par['max_n_links'], 'weight') - - print('Remaining net size: ', net.shape, ' TF size: ', net['source'].nunique(), ' common TFs: ', tfs_common.shape) - - # - calculate the scores - wasserstein_distances = [] - links = [] - for tf in tqdm(tfs_common): - edges = net[net['source']==tf] - for parent, child in zip(edges['source'],edges['target']): #multiple cuts + prediction = pd.read_csv(par['prediction'], index_col=0) + consensus = pd.read_csv(par['ws_consensus'], index_col=0) + background_distance = pd.read_csv(par['ws_distance_background'], index_col=0) + evaluation_data = ad.read_h5ad(par['evaluation_data_sc']) + evaluation_data.X = evaluation_data.layers[par['layer']] + + # - for each theta, and each tf: + scores_model = [] + for theta in consensus['theta'].unique(): + consensus_theta = consensus[consensus['theta'] == theta] + for tf in consensus_theta['source'].unique(): + if tf not in prediction['source'].unique(): # skip the evaluation if tf is not given in the predictions + continue + # - get the prior + background_distance_tf = background_distance[background_distance['source']==tf] + n_edges = consensus_theta[consensus_theta['source'] == tf]['value'].values[0] + # - subset the prediction to the given tf: choose the top edges based on n_edges + prediction_tf = prediction[prediction['source']==tf] + prediction_tf = prediction_tf.nlargest(n_edges, 'weight') + # - get the ws distance + ws_distance = background_distance_tf[background_distance_tf['target'].isin(prediction_tf['target'])].copy() + # - fill the missing links with random scores + n_missing = n_edges - len(ws_distance) + ws_distance_missing = background_distance_tf.sample(n_missing, replace=True) + ws_distance = pd.concat([ws_distance, ws_distance_missing]) + ws_distance['present_edges_n'] = len(ws_distance) + # - normalize to the background dist -> percentile rank + background_distance_random = np.random.choice(background_distance_tf['ws_distance'].values, 1000) + ws_distance_pc = ws_distance['ws_distance'].apply(lambda val: (val>background_distance_random).sum())/len(background_distance_random) + ws_distance['ws_distance_pc'] = ws_distance_pc - get_observational(child) - observational_samples = get_observational(child) - interventional_samples = get_interventional(child, parent) - - wasserstein_distance = scipy.stats.wasserstein_distance( - observational_samples.reshape(-1), interventional_samples.reshape(-1) - ) - wasserstein_distances.append(wasserstein_distance) - links.append(f'{parent}_{child}') - mean_score = np.mean(wasserstein_distances) - return mean_score, wasserstein_distances, links - + ws_distance['theta'] = theta + scores_model.append(ws_distance) + scores_model = pd.concat(scores_model).reset_index(drop=True) + mean_scores = scores_model.groupby('theta')['ws_distance_pc'].mean().to_frame().T.reset_index(drop=True) + return scores_model, mean_scores if __name__ == '__main__': - if False: - mean_score, wasserstein_distances, links = main(par) - #TODO: put this into right format - else: - output_dir = 'output' - datasets = ['adamson', 'norman'] - models = ['pearson_corr', 'grnboost2','portia', 'ppcor','scenic'] - n_maxs = [500, 1000, 5000, 10000, 50000] - - - for dataset in datasets: - print(dataset) - scores_all = [] - for model in models: - par['evaluation_data'] = f'resources/datasets_raw/{dataset}_sc_counts.h5ad' - par['prediction'] = f'resources/grn_models/{dataset}/{model}.csv' - if not os.path.exists(par['prediction']): - print(f'Skip {dataset}-{model}') - continue - for n_max in n_maxs: - par['max_n_links'] = n_max - - _, wasserstein_distances, links = main(par) - for score, link in zip(wasserstein_distances, links): - scores_all.append({'model':model, 'n_max':n_max, 'link':link, 'score':score}) - scores_all = pd.DataFrame(scores_all) - scores_all.to_csv(f'{output_dir}/scores_{dataset}.csv') - \ No newline at end of file + _, mean_scores = main(par) + + output = ad.AnnData( + X=np.empty((0, 0)), + uns={ + "dataset_id": str(par["dataset_id"]), + "method_id": f"reg2-{par['method_id']}", + "metric_ids": mean_scores.columns, + "metric_values": mean_scores.values[0] + } + ) + output.write_h5ad(par['score'], compression='gzip') + print('Completed', flush=True) \ No newline at end of file diff --git a/src/metrics/wasserstein/script_all.py b/src/metrics/wasserstein/script_all.py new file mode 100644 index 00000000..86f4bca8 --- /dev/null +++ b/src/metrics/wasserstein/script_all.py @@ -0,0 +1,63 @@ +import pandas as pd +import anndata as ad +import sys +import numpy as np +import os + +from script import main +from consensus.script import main as main_consensus +from background_scores.script import main as main_background_score + +# acutal evaluation -> all + + +par = { + 'datasets': ['adamson', 'norman'], + 'models': ['pearson_corr', 'grnboost2', 'portia', 'ppcor', 'scenic'], + 'evaluation_data_sc': 'resources/datasets_raw/adamson_sc_counts.h5ad', + 'mean_scores_all': 'resources/scores/ws_distance_mean.csv', + 'scores_all': 'resources/scores/ws_distance.csv', + 'consensus': 'resources/prior/consensus_ws_distance_adamson.csv', + 'tf_all': 'resources/prior/tf_all.csv', + 'background_distance':'resources/prior/ws_distance_background_adamson.csv', + 'layer': 'X_norm', +} + +def main(par): + mean_scores_store = [] + scores_store = [] + for dataset in par['datasets']: + par['grns_dir'] = f'resources/grn_models/{dataset}' + + par['evaluation_data_sc'] = f'resources/datasets_raw/{dataset}_sc_counts.h5ad' + par['consensus'] = f'resources/prior/consensus_ws_distance_{dataset}.csv' + par['background_distance'] = f'resources/prior/ws_distance_background_{dataset}.csv' + + if True: + main_consensus(par) + if False: + main_background_score(par) + + for model in par['models']: + par['prediction'] = f'resources/grn_models/{dataset}/{model}.csv' + if not os.path.exists(par['prediction']): + continue + scores_model = main(par) + mean_score = scores_model.groupby('theta')['ws_distance_pc'].mean().to_frame().T.reset_index(drop=True) + mean_score['dataset'] = dataset + mean_score['model'] = model + mean_scores_store.append(mean_score) + + # - also store raw scores + scores_model['dataset'] = dataset + scores_model['model'] = model + scores_store.append(scores_model) + mean_scores_all = pd.concat(mean_scores_store) + scores_all = pd.concat(scores_store) + + return mean_scores_all, scores_all + +if __name__ == '__main__': + mean_scores_all, scores_all = main(par) + mean_scores_all.to_csv(par['mean_scores_all']) + scores_all.to_csv(par['scores_all']) \ No newline at end of file diff --git a/src/metrics/skeleton/script.py b/src/robustness_analysis/skeleton/script.py similarity index 100% rename from src/metrics/skeleton/script.py rename to src/robustness_analysis/skeleton/script.py