{ "cells": [ { "cell_type": "code", "execution_count": 1, "id": "ea141d2c", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import pandas as pd\n", "from scipy import stats, sparse\n", "import bottleneck\n", "from scipy.stats import mannwhitneyu" ] }, { "cell_type": "code", "execution_count": 2, "id": "7cf78cd3", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import pandas as pd\n", "from scipy import stats, sparse\n", "import bottleneck\n", "def run_egad(go, nw, **kwargs):\n", " \"\"\"EGAD running function\n", " \n", " Wrapper to lower level functions for EGAD\n", "\n", " EGAD measures modularity of gene lists in co-expression networks. \n", "\n", " This was translated from the MATLAB version, which does tiled Cross Validation\n", " \n", " The useful kwargs are:\n", " int - nFold : Number of CV folds to do, default is 3, \n", " int - {min,max}_count : limits for number of terms in each gene list, these are exclusive values\n", "\n", "\n", " Arguments:\n", " go {pd.DataFrame} -- dataframe of genes x terms of values [0,1], where 1 is included in gene lists\n", " nw {pd.DataFrame} -- dataframe of co-expression network, genes x genes\n", " **kwargs \n", " \n", " Returns:\n", " pd.DataFrame -- dataframe of terms x metrics where the metrics are \n", " ['AUC', 'AVG_NODE_DEGREE', 'DEGREE_NULL_AUC', 'P_Value']\n", " \"\"\"\n", " assert nw.shape[0] == nw.shape[1] , 'Network is not square'\n", " #print(nw.index)\n", " #nw.columns = nw.columns.astype(int)\n", " #print(nw.columns.astype(int))\n", " assert np.all(nw.index == nw.columns) , 'Network index and columns are not in the same order'\n", "\n", " #nw_mask = nw.isna().sum(axis=1) != nw.shape[1]\n", " #nw = nw.loc[nw_mask, nw_mask].astype('float')\n", " #np.fill_diagonal(nw.values, 1)\n", " return _runNV(go, nw, **kwargs)\n", "\n", "def _runNV(go, nw, nFold=3, min_count=10, max_count=1000000):\n", "\n", " #Make sure genes are same in go and nw\n", " #go.index = go.index.map(str) \n", " #nw.index = nw.index.map(str)\n", " #nw.index = nw.index.str.replace('_', '')\n", " #go.index = go.index.str.replace('_', '')\n", " #print (nw)\n", " genes_intersect = go.index.intersection(nw.index)\n", "\n", "\n", " #print (genes_intersect)\n", " go = go.loc[genes_intersect, :]\n", " nw = nw.loc[genes_intersect, genes_intersect]\n", " #print (go)\n", " print (nw.shape)\n", " print (go.shape)\n", " sparsity = 1.0 - np.count_nonzero(go) / go.size\n", " print (sparsity)\n", " sparsity = 1.0 - np.count_nonzero(nw) / nw.size\n", " print (sparsity)\n", " #print(nw\n", " #print(go\n", " nw_mask = nw.isna().sum(axis=1) != nw.shape[1]\n", " nw = nw.loc[nw_mask, nw_mask].astype('float')\n", " np.fill_diagonal(nw.values, 1)\n", " #Make sure there aren't duplicates\n", " duplicates = nw.index.duplicated(keep='first')\n", " nw = nw.loc[~duplicates, ~duplicates]\n", "\n", " go = go.loc[:, (go.sum(axis=0) > min_count) & (go.sum(axis=0) < max_count)]\n", " go = go.loc[~go.index.duplicated(keep='first'), :]\n", " #print(go)\n", "\n", " roc = _new_egad(go.values, nw.values, nFold)\n", "\n", " col_names = ['AUC', 'AVG_NODE_DEGREE', 'DEGREE_NULL_AUC', 'P_Value']\n", " #Put output in dataframe\n", " return pd.DataFrame(dict(zip(col_names, roc)), index=go.columns), go\n", "\n", "def _new_egad(go, nw, nFold):\n", "\n", " #Build Cross validated Positive\n", " x, y = np.where(go)\n", " #print(x, y)\n", " cvgo = {}\n", " for i in np.arange(nFold):\n", " a = x[i::nFold]\n", " #print(a)\n", " b = y[i::nFold]\n", " dat = np.ones_like(a)\n", " mask = sparse.coo_matrix((dat, (a, b)), shape=go.shape)\n", " cvgo[i] = go - mask.toarray()\n", "\n", " CVgo = np.concatenate(list(cvgo.values()), axis=1)\n", " #print(CVgo)\n", "\n", " sumin = np.matmul(nw.T, CVgo)\n", "\n", " degree = np.sum(nw, axis=0)\n", " #print(degree)\n", " #print(degree[:, None])\n", "\n", " predicts = sumin / degree[:, None]\n", " #print(predicts)\n", "\n", " np.place(predicts, CVgo > 0, np.nan)\n", "\n", " #print(predicts)\n", "\n", " #Calculate ranks of positives\n", " rank_abs = lambda x: stats.rankdata(np.abs(x))\n", " predicts2 = np.apply_along_axis(rank_abs, 0, predicts)\n", " #print(predicts2)\n", "\n", " #Masking Nans that were ranked (how tiedrank works in matlab)\n", " predicts2[np.isnan(predicts)] = np.nan\n", " #print(predicts2)\n", "\n", " filtering = np.tile(go, nFold)\n", " #print(filtering)\n", "\n", " #negatives :filtering == 0\n", " #Sets Ranks of negatives to 0\n", " np.place(predicts2, filtering == 0, 0)\n", "\n", " #Sum of ranks for each prediction\n", " p = bottleneck.nansum(predicts2, axis=0)\n", " n_p = np.sum(filtering, axis=0) - np.sum(CVgo, axis=0)\n", "\n", " #Number of negatives\n", " #Number of GO terms - number of postiive\n", " n_n = filtering.shape[0] - np.sum(filtering, axis=0)\n", "\n", " roc = (p / n_p - (n_p + 1) / 2) / n_n\n", " U = roc * n_p * n_n\n", " Z = (np.abs(U - (n_p * n_n / 2))) / np.sqrt(n_p * n_n *\n", " (n_p + n_n + 1) / 12)\n", " roc = roc.reshape(nFold, go.shape[1])\n", " Z = Z.reshape(nFold, go.shape[1])\n", " #Stouffer Z method\n", " Z = bottleneck.nansum(Z, axis=0) / np.sqrt(nFold)\n", " #Calc ROC of Neighbor Voting\n", " roc = bottleneck.nanmean(roc, axis=0)\n", " P = stats.norm.sf(Z)\n", "\n", " #Average degree for nodes in each go term\n", " avg_degree = degree.dot(go) / np.sum(go, axis=0)\n", "\n", " #Calc null auc for degree\n", " ranks = np.tile(stats.rankdata(degree), (go.shape[1], 1)).T\n", "\n", " np.place(ranks, go == 0, 0)\n", "\n", " n_p = bottleneck.nansum(go, axis=0)\n", " nn = go.shape[0] - n_p\n", " p = bottleneck.nansum(ranks, axis=0)\n", "\n", " roc_null = (p / n_p - ((n_p + 1) / 2)) / nn\n", " #print(roc)\n", " return roc, avg_degree, roc_null, P" ] }, { "cell_type": "code", "execution_count": 4, "id": "b402c242", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "INFO:numexpr.utils:Note: detected 192 virtual cores but NumExpr set to maximum of 64, check \"NUMEXPR_MAX_THREADS\" environment variable.\n", "INFO:numexpr.utils:Note: NumExpr detected 192 cores but \"NUMEXPR_MAX_THREADS\" not set, so enforcing safe limit of 8.\n", "INFO:numexpr.utils:NumExpr defaulting to 8 threads.\n" ] } ], "source": [ "from hicmatrix import HiCMatrix as hm\n", "from hicmatrix.lib import MatrixFileHandler" ] }, { "cell_type": "code", "execution_count": 5, "id": "6086839a", "metadata": {}, "outputs": [], "source": [ "exp_file_path=f'/grid/gillis/data/lohia/hi_c_data_processing/software/CoCoCoNet/networks/human_prioAggNet.h5'\n", "\n", "jac_exp = hm.hiCMatrix(exp_file_path)\n", "all_genes = [x[3].decode() for x in jac_exp.cut_intervals]\n", "df_exp_corr = pd.DataFrame(jac_exp.matrix.toarray() , index=all_genes, columns = all_genes)" ] }, { "cell_type": "code", "execution_count": 6, "id": "a3e0922b", "metadata": {}, "outputs": [], "source": [ "resolution_human = 10000\n", "species = \"human\"\n", "SRP_name = \"aggregates\"\n", "resolution = \"10kbp_raw\"\n", "\n", "\n", "\n", "input_path=f'/grid/gillis/data/lohia/hi_c_data_processing/data_{species}/{SRP_name}/{resolution}/max/'\n", "bins_bed = pd.read_csv(f'{input_path}/all_bins.bed', names=['chr', 'start', 'end', 'bin_id'])" ] }, { "cell_type": "code", "execution_count": 7, "id": "5532edb2", "metadata": {}, "outputs": [], "source": [ " if species == 'human':\n", "\n", " df_cre = pd.read_csv('/grid/gillis/data/lohia/hi_c_data_processing/data_human/aggregates/li2022/GRCh38-cCREs.bed', sep='\\t', names=['chr', 'start', 'end', 't1', 't2', 't3'])\n", "\n", " else:\n", "\n", " df_cre = pd.read_csv('/grid/gillis/data/lohia/ATAC_Risa/mm10-cCREs.bed', sep='\\t', names=['chr', 'start', 'end', 't1', 't2', 't3'])\n", "\n", " df_cre['start_bin'] = df_cre['start']/resolution_human\n", " df_cre['start_bin'] = df_cre['start_bin'].astype('int')\n", " df_cre['start_bin'] = df_cre['start_bin']*resolution_human\n", " df_cre['start_bin'] = df_cre['start_bin'].astype('str')\n", " df_cre['start_bin'] = df_cre['chr'] + '_' + df_cre['start_bin']\n", " #df_cre_1kb_encode = df_cre.drop_duplicates(subset=['start_bin'])\n", " df_cre['cre'] = 1\n", " df_cre = df_cre.groupby(['start_bin'])['cre'].sum().reset_index()\n", " input_path=f'/grid/gillis/data/lohia/hi_c_data_processing/data_{species}/{SRP_name}/{resolution}/max/'\n", " bins_bed = pd.read_csv(f'{input_path}/all_bins.bed', names=['chr', 'start', 'end', 'bin_id'])\n", " bins_bed['bin_id'] = bins_bed.index\n", " bins_bed['pos'] = bins_bed['chr'] + '_' + bins_bed['start'].astype('str')\n", " df_cre_1kb_encode = df_cre.merge(bins_bed, left_on='start_bin', right_on='pos')\n", " " ] }, { "cell_type": "code", "execution_count": 8, "id": "3e7bd086", "metadata": {}, "outputs": [], "source": [ "from hicmatrix import HiCMatrix as hm\n", "from hicmatrix.lib import MatrixFileHandler\n", "import numpy as np\n", "import pandas as pd\n", "from scipy import stats, sparse\n", "import bottleneck\n", "from scipy.stats import mannwhitneyu\n", "import h5py\n", "import h5py\n", "import logging\n", "import numpy as np\n", "import pandas as pd\n", "from hicmatrix import HiCMatrix as hm\n", "from hicmatrix.lib import MatrixFileHandler\n", "from scipy.sparse import csr_matrix, dia_matrix, triu, tril, coo_matrix\n", "import scipy.stats as stats\n", "import os.path" ] }, { "cell_type": "code", "execution_count": 9, "id": "d03fd8d4", "metadata": {}, "outputs": [], "source": [ "with h5py.File(f'/grid/gillis/data/lohia/hi_c_data_processing/data_{species}/{SRP_name}/{resolution}/max/hic_gene_gw_none_by_allbins_none_ranked_inter.h5', 'r') as hf:\n", " my_data = hf['matrix'][:]\n", " gene_list = hf['gene_list'][:]\n", " bins_bed = hf['bins_bed'][:]" ] }, { "cell_type": "code", "execution_count": 11, "id": "3be24c11", "metadata": {}, "outputs": [], "source": [ "my_percen = np.nanpercentile(my_data, 99, axis=1, keepdims=True)" ] }, { "cell_type": "code", "execution_count": 12, "id": "526480eb", "metadata": {}, "outputs": [], "source": [ "my_data_thresh = my_data > my_percen\n", "\n", "my_data_thresh = my_data_thresh.astype(int)" ] }, { "cell_type": "code", "execution_count": 13, "id": "7b69abf9", "metadata": {}, "outputs": [], "source": [ "df_gene_tp = pd.DataFrame(my_data_thresh , index=[x.decode() for x in gene_list.tolist()], columns = bins_bed.tolist())\n" ] }, { "cell_type": "code", "execution_count": 14, "id": "e5d02b91", "metadata": {}, "outputs": [], "source": [ "exp_genes = pd.read_csv(\"/grid/gillis/data/lohia/hi_c_data_processing/software/CoCoCoNet/Homo_sapiens_average_rank.csv\")\n", "\n", "exp_genes['genes'] = [x.split('.')[0] for x in exp_genes['genes']]\n", "\n", "exp_genes.set_index('genes', inplace=True)\n", "\n", "exp_genes['avg_rank'] = exp_genes.sum(axis=1)\n", "\n", "exp_genes['avg_rank'] = [ x/ exp_genes.shape[1] for x in exp_genes['avg_rank']]\n", "\n", "exp_genes = exp_genes[['avg_rank']]\n", "\n", "exp_genes.reset_index(inplace=True)\n", "\n", "exp_genes.drop_duplicates(['genes'], inplace=True)" ] }, { "cell_type": "code", "execution_count": 15, "id": "59c5598d", "metadata": {}, "outputs": [], "source": [ "high_auc_gene = exp_genes[exp_genes['avg_rank'] > 0.7]['genes'].tolist()" ] }, { "cell_type": "code", "execution_count": 16, "id": "1f626939", "metadata": {}, "outputs": [], "source": [ "df_gene_tp_sel = df_gene_tp[df_gene_tp.index.isin(high_auc_gene)]" ] }, { "cell_type": "code", "execution_count": 17, "id": "f5702b8b", "metadata": {}, "outputs": [], "source": [ "cre_bins = df_cre_1kb_encode[df_cre_1kb_encode['cre']>14]['bin_id'].tolist()" ] }, { "cell_type": "code", "execution_count": 18, "id": "0bbae578", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2.780666666666667" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "len(cre_bins)/3000" ] }, { "cell_type": "code", "execution_count": 19, "id": "d7ddb46e", "metadata": {}, "outputs": [], "source": [ "df_gene_tp_sel = df_gene_tp_sel[cre_bins]" ] }, { "cell_type": "code", "execution_count": 20, "id": "e72f6d7e", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(13157, 13157)\n", "(13157, 8342)\n", "0.9693905994526353\n", "0.0\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ ":133: RuntimeWarning: invalid value encountered in true_divide\n", " roc = (p / n_p - (n_p + 1) / 2) / n_n\n" ] } ], "source": [ "df_2d_jac, go_chrom = run_egad(df_gene_tp_sel, df_exp_corr)" ] }, { "cell_type": "code", "execution_count": 22, "id": "396d06db", "metadata": {}, "outputs": [], "source": [ "%matplotlib inline\n", "import seaborn as sns" ] }, { "cell_type": "code", "execution_count": 23, "id": "978e41dd", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/grid/gillis/home/lohia/.conda/envs/hicexplorer/lib/python3.8/site-packages/seaborn/_decorators.py:36: FutureWarning: Pass the following variables as keyword args: x, y. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n", " warnings.warn(\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 23, "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", "sns.scatterplot(df_2d_jac['AUC'], df_2d_jac['DEGREE_NULL_AUC'])\n", "plt.plot([0, 1], [0, 1], c='black')\n", "plt.axvline(x=df_2d_jac['AUC'].mean(),c='black',ls='--')\n", "plt.axhline(y=df_2d_jac['DEGREE_NULL_AUC'].mean(), c='black', ls='--')" ] }, { "cell_type": "code", "execution_count": 25, "id": "1954db7d", "metadata": {}, "outputs": [], "source": [ "df_t = df_2d_jac.merge(df_gene_tp_sel.sum().reset_index(), left_on=df_2d_jac.index, right_on='index')\n" ] }, { "cell_type": "code", "execution_count": 26, "id": "1060c9b9", "metadata": {}, "outputs": [ { "data": { "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", "
AUCAVG_NODE_DEGREEDEGREE_NULL_AUCP_Valueindex0
00.54864810432.2513300.5000192.071635e-02177492147
10.59345410135.5782460.4425645.234711e-0217755726
20.53645410060.6682460.4078402.975338e-0117756520
30.62454310300.1791060.4781415.764654e-07177566127
40.46189710385.4440570.5161286.432477e-02177580129
.....................
78760.60138910454.0277720.5109801.831122e-08163474249
78770.56014910544.3219320.5298884.074555e-03163477159
78780.52562910027.9083660.4159762.571734e-0116355760
78790.66011110531.9339670.4986883.683678e-0316356232
78800.69296910628.6372470.5471721.431164e-17163634162
\n", "

7881 rows × 6 columns

\n", "
" ], "text/plain": [ " AUC AVG_NODE_DEGREE DEGREE_NULL_AUC P_Value index 0\n", "0 0.548648 10432.251330 0.500019 2.071635e-02 177492 147\n", "1 0.593454 10135.578246 0.442564 5.234711e-02 177557 26\n", "2 0.536454 10060.668246 0.407840 2.975338e-01 177565 20\n", "3 0.624543 10300.179106 0.478141 5.764654e-07 177566 127\n", "4 0.461897 10385.444057 0.516128 6.432477e-02 177580 129\n", "... ... ... ... ... ... ...\n", "7876 0.601389 10454.027772 0.510980 1.831122e-08 163474 249\n", "7877 0.560149 10544.321932 0.529888 4.074555e-03 163477 159\n", "7878 0.525629 10027.908366 0.415976 2.571734e-01 163557 60\n", "7879 0.660111 10531.933967 0.498688 3.683678e-03 163562 32\n", "7880 0.692969 10628.637247 0.547172 1.431164e-17 163634 162\n", "\n", "[7881 rows x 6 columns]" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df_t" ] }, { "cell_type": "code", "execution_count": 28, "id": "490e14bb", "metadata": {}, "outputs": [], "source": [ "df_t['quintile'] = pd.qcut(df_t[0] , 10, labels=np.arange(10, 0, -1))" ] }, { "cell_type": "code", "execution_count": 29, "id": "3fdbb02c", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/grid/gillis/home/lohia/.conda/envs/hicexplorer/lib/python3.8/site-packages/seaborn/_decorators.py:36: FutureWarning: Pass the following variables as keyword args: x, y. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n", " warnings.warn(\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "sns.boxplot(df_t['quintile'], df_t['AUC'])" ] }, { "cell_type": "code", "execution_count": 34, "id": "1205a311", "metadata": {}, "outputs": [ { "ename": "NameError", "evalue": "name 'kl' is not defined", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mkl\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mNameError\u001b[0m: name 'kl' is not defined" ] } ], "source": [ "kl" ] }, { "cell_type": "code", "execution_count": 31, "id": "0dfb9a48", "metadata": {}, "outputs": [ { "data": { "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", "
AUCAVG_NODE_DEGREEDEGREE_NULL_AUCP_Valueindex0quintile
50.61639310677.1105810.5749542.229388e-6817759119831
140.66338910572.3408110.5441119.583433e-10517771615361
150.70715310588.8458150.5397165.304060e-17417773116041
180.70747810582.9089730.5417112.018835e-23417773522061
230.59815810705.3178710.5886702.556946e-6317776326361
........................
77610.64228010809.8336240.6107192.569722e-12215695424421
77660.52647010515.7064320.5290046.451476e-0415699612771
77690.51880310666.1000790.5771768.463337e-0415708925031
77740.57720610723.2433490.5917328.175634e-3815716324671
77780.70211310578.2503680.5377833.649385e-18815721718391
\n", "

787 rows × 7 columns

\n", "
" ], "text/plain": [ " AUC AVG_NODE_DEGREE DEGREE_NULL_AUC P_Value index 0 \\\n", "5 0.616393 10677.110581 0.574954 2.229388e-68 177591 1983 \n", "14 0.663389 10572.340811 0.544111 9.583433e-105 177716 1536 \n", "15 0.707153 10588.845815 0.539716 5.304060e-174 177731 1604 \n", "18 0.707478 10582.908973 0.541711 2.018835e-234 177735 2206 \n", "23 0.598158 10705.317871 0.588670 2.556946e-63 177763 2636 \n", "... ... ... ... ... ... ... \n", "7761 0.642280 10809.833624 0.610719 2.569722e-122 156954 2442 \n", "7766 0.526470 10515.706432 0.529004 6.451476e-04 156996 1277 \n", "7769 0.518803 10666.100079 0.577176 8.463337e-04 157089 2503 \n", "7774 0.577206 10723.243349 0.591732 8.175634e-38 157163 2467 \n", "7778 0.702113 10578.250368 0.537783 3.649385e-188 157217 1839 \n", "\n", " quintile \n", "5 1 \n", "14 1 \n", "15 1 \n", "18 1 \n", "23 1 \n", "... ... \n", "7761 1 \n", "7766 1 \n", "7769 1 \n", "7774 1 \n", "7778 1 \n", "\n", "[787 rows x 7 columns]" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df_t[df_t['quintile'] == 1]" ] }, { "cell_type": "code", "execution_count": null, "id": "6dfa454b", "metadata": {}, "outputs": [], "source": [ "kl" ] }, { "cell_type": "code", "execution_count": null, "id": "f157531b", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "hicexp", "language": "python", "name": "hicexp" }, "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.8.10" } }, "nbformat": 4, "nbformat_minor": 5 }