02a_bootstrapped_disease_comparisons.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\melis\\AppData\\Local\\Programs\\Python\\Python37\\lib\\site-packages\\tqdm\\auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import mygene\n",
    "import omnipath as op\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import os\n",
    "import glob\n",
    "import mellon as ml\n",
    "from pyensembl import EnsemblRelease\n",
    "import random\n",
    "import netrd\n",
    "import networkx as nx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import gtex expression data\n",
    "\n",
    "gtex_link = 'raw_data/GTEx_tissue_data/GTEx_Analysis_2017-06-05_v8_RNASeQCv1.1.9_gene_median_tpm.gct.gz'\n",
    "exp = pd.read_csv(gtex_link, sep='\\t', index_col='Description', skiprows=2)\n",
    "exp_cns = exp\n",
    "#exp_cns = exp.loc[:, ['Brain - Amygdala',\n",
    "#       'Brain - Anterior cingulate cortex (BA24)',\n",
    "#       'Brain - Caudate (basal ganglia)', 'Brain - Cerebellar Hemisphere',\n",
    "#       'Brain - Cerebellum', 'Brain - Cortex', 'Brain - Frontal Cortex (BA9)',\n",
    "#       'Brain - Hippocampus', 'Brain - Hypothalamus',\n",
    "#       'Brain - Nucleus accumbens (basal ganglia)',\n",
    "#       'Brain - Putamen (basal ganglia)', 'Brain - Spinal cord (cervical c-1)',\n",
    "#       'Brain - Substantia nigra']]\n",
    "#exp_cns = exp.loc[(exp_cns > 0).any(axis=1)]\n",
    "\n",
    "# import omnipath db\n",
    "db = op.interactions.import_intercell_network(transmitter_params = {\"categories\":\"ligand\"}, receiver_params = {\"categories\": \"receptor\"})\n",
    "db = db[np.logical_not(db['genesymbol_intercell_source'].str.startswith('HLA'))]\n",
    "db = db[np.logical_not(db['genesymbol_intercell_target'].str.startswith('HLA'))]\n",
    "db = db[~db['genesymbol_intercell_target'].astype(str).str.startswith('COMPLEX')]\n",
    "db = db[~db['genesymbol_intercell_source'].astype(str).str.startswith('COMPLEX')]\n",
    "\n",
    "# specify the release number\n",
    "ensembl = EnsemblRelease(109)\n",
    "genes = ensembl.genes()\n",
    "\n",
    "mg = mygene.MyGeneInfo()\n",
    "ensembl_gtex = list(np.unique(pd.DataFrame(list(exp_cns.index.str.split('.')))[0]))\n",
    "\n",
    "# create a DataFrame of gene information\n",
    "ensembl_ann = pd.DataFrame({\n",
    "    'gene_id': [gene.gene_id for gene in genes],\n",
    "    'gene_name': [gene.gene_name for gene in genes],\n",
    "    'chromosome': [gene.contig for gene in genes],\n",
    "    'type': [gene.biotype for gene in genes]\n",
    "})\n",
    "gtex_annotated = ensembl_ann[ensembl_ann['gene_name'].isin(ensembl_gtex)] # take list of genes expressed in brain\n",
    "protein = gtex_annotated[gtex_annotated['type']=='protein_coding']        # take protein-expressing ones\n",
    "protein = protein.rename(columns={'gene_name':'gene'}).set_index('gene', drop=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_source, pctsrc, all_targets, pcttgt, summary_universe_LR = ml.lr.find_hits(protein,db)  # of these proteins, which LRs are expressed?\n",
    "universe_LRs = list(pd.concat([all_source['gene'],all_targets['gene']]).unique()) # define universe of LRs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# \n",
    "reference = pd.read_csv('processed_data/hot-encoded-diseases_0.400000.csv', index_col=0)                     # take actual disease genes\n",
    "df = reference[reference.index.isin(list(ensembl_ann[ensembl_ann['type']=='protein_coding']['gene_name']))]  # take protein coding ones\n",
    "df = df.reset_index().rename(columns={'genes':'gene'}).set_index('gene', drop = True)\n",
    "all_source, pctsrc, all_targets, pcttgt, summary_LR = ml.lr.find_hits(df,db)    \n",
    "disease_LRs = summary_LR[summary_LR['source+target']!='None']              \n",
    "reference = reference[reference.index.isin(list(disease_LRs['gene']))]                                        # filter reference to only include LRs\n",
    "disease_list = list(reference.columns)\n",
    "universe_LRs = list(set(universe_LRs) - (set(universe_LRs) & set(list(disease_LRs['gene'])))) # Remove from universe any disease-associated proteins\n",
    "iter=12\n",
    "count = 0\n",
    "all_LR_intersects = pd.DataFrame(np.zeros(shape=(iter, pow(len(disease_list), 2))))\n",
    "all_LRI_intersects = pd.DataFrame(np.zeros(shape=(iter, pow(len(disease_list), 2))))\n",
    "all_distances = pd.DataFrame(np.zeros(shape=(iter, pow(len(disease_list), 2))))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "for disease1 in disease_list:\n",
    "    for disease2 in disease_list:\n",
    "            all_LR_intersects.rename(columns = {count : disease1+'/'+disease2}, inplace = True)\n",
    "            all_LRI_intersects.rename(columns = {count : disease1+'/'+disease2}, inplace = True)\n",
    "            all_distances.rename(columns = {count : disease1+'/'+disease2}, inplace = True)\n",
    "            if (disease2+'/'+disease1) in all_distances.columns:\n",
    "                all_LR_intersects[disease1+'/'+disease2] = all_LR_intersects[disease2+'/'+disease1]\n",
    "                all_LRI_intersects[disease1+'/'+disease2] = all_LRI_intersects[disease2+'/'+disease1]\n",
    "                all_distances[disease1+'/'+disease2] = all_distances[disease2+'/'+disease1]\n",
    "            else:\n",
    "                for i in range(0,iter):\n",
    "                    # Create random list comparable to each disease\n",
    "                    rand_disease1 = random.sample(list(range(0,len(universe_LRs))), int(reference[disease1].sum()))\n",
    "                    rand_disease2 = random.sample(list(range(0,len(universe_LRs))), int(reference[disease2].sum()))\n",
    "                    genes_disease1 = list(pd.DataFrame(universe_LRs).iloc[rand_disease1][0])\n",
    "                    genes_disease2 = list(pd.DataFrame(universe_LRs).iloc[rand_disease2][0])\n",
    "\n",
    "                    # Check intersect of lists, add total number to all_intersects list\n",
    "                    LR_intersect = len(list(set(genes_disease1) & set(genes_disease2)))\n",
    "                    all_LR_intersects.iloc[i, count] = LR_intersect\n",
    "                    \n",
    "                    ### How many LRIs do random disease 1 and random disease 2 share?\n",
    "                    # Get all LRIs where at least one is linked to diseases \n",
    "                    LRs_disease1 = db[['genesymbol_intercell_source','genesymbol_intercell_target']][(db['genesymbol_intercell_source'].isin(list(genes_disease1))) | (db['genesymbol_intercell_target'].isin(list(genes_disease1)))]\n",
    "                    LRs_disease2 = db[['genesymbol_intercell_source','genesymbol_intercell_target']][(db['genesymbol_intercell_source'].isin(list(genes_disease2))) | (db['genesymbol_intercell_target'].isin(list(genes_disease2)))]\n",
    "                    LRs_disease1 = LRs_disease1.dropna()\n",
    "                    LRs_disease2 = LRs_disease2.dropna()\n",
    "                    LRs_disease1_list = list(LRs_disease1['genesymbol_intercell_source']+LRs_disease1['genesymbol_intercell_target'])\n",
    "                    LRs_disease2_list = list(LRs_disease2['genesymbol_intercell_source']+LRs_disease2['genesymbol_intercell_target'])\n",
    "                    \n",
    "                    # Check intersect of lists\n",
    "                    LRI_intersect = len(list(set(LRs_disease1_list) & set(LRs_disease2_list)))\n",
    "                    all_LRI_intersects.iloc[i, count] = LRI_intersect\n",
    "\n",
    "                    ### How close are the random LR networks?\n",
    "                    # Build an adjacency matrix per disease\n",
    "                    unique_LRs_disease1 = pd.DataFrame(pd.concat([LRs_disease1['genesymbol_intercell_source'],LRs_disease1['genesymbol_intercell_target']], axis = 0).unique())\n",
    "                    unique_LRs_disease2 = pd.DataFrame(pd.concat([LRs_disease2['genesymbol_intercell_source'],LRs_disease2['genesymbol_intercell_target']], axis = 0).unique())\n",
    "                    both_unique = pd.concat([unique_LRs_disease1, unique_LRs_disease2], axis = 0)[0].unique()\n",
    "                    # For deltacon comparison, the axes of the adjacency matrix must be the same\n",
    "                    adj_LRs_disease1 = pd.DataFrame(np.zeros(shape=(len(both_unique), len(both_unique))), index = both_unique, columns = both_unique)\n",
    "                    adj_LRs_disease2 = pd.DataFrame(np.zeros(shape=(len(both_unique), len(both_unique))), index = both_unique, columns = both_unique)\n",
    "                    for n in range (0, np.shape(LRs_disease1)[0]):\n",
    "                        adj_LRs_disease1.iloc[adj_LRs_disease1.index.get_loc(LRs_disease1.iloc[n]['genesymbol_intercell_source']), adj_LRs_disease1.columns.get_loc(LRs_disease1.iloc[n]['genesymbol_intercell_target'])] += 1\n",
    "                    for n in range (0, np.shape(LRs_disease2)[0]):\n",
    "                        adj_LRs_disease2.iloc[adj_LRs_disease2.index.get_loc(LRs_disease2.iloc[n]['genesymbol_intercell_source']), adj_LRs_disease2.columns.get_loc(LRs_disease2.iloc[n]['genesymbol_intercell_target'])] += 1\n",
    "                    if (len(LRs_disease1)<1) or (len(LRs_disease2)<1):\n",
    "                        all_distances.iloc[i, count] = 99\n",
    "                    else:\n",
    "                        # Create network and detect communities\n",
    "                        G1 = nx.from_pandas_adjacency(adj_LRs_disease1)\n",
    "                        G2 = nx.from_pandas_adjacency(adj_LRs_disease2)\n",
    "                        # Calculate network distance\n",
    "                        delta = netrd.distance.DeltaCon()\n",
    "                        distance = delta.dist(G1, G2)\n",
    "\n",
    "                        all_distances.iloc[i, count] = distance\n",
    "            count+=1 \n",
    "\n",
    "all_LR_intersects.to_csv('processed_data/02a_bootstrapped_disease_comparisons/bootstrapped_LRs_disease_comparisons.csv')\n",
    "all_LRI_intersects.to_csv('processed_data/02a_bootstrapped_disease_comparisons/bootstrapped_LRIs_disease_comparisons.csv')\n",
    "all_distances.to_csv('processed_data/02a_bootstrapped_disease_comparisons/bootstrapped_distances_disease_comparisons.csv')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "reference = pd.read_csv('processed_data/hot-encoded-diseases_0.400000.csv', index_col=0)\n",
    "df = reference[reference.index.isin(list(ensembl_ann[ensembl_ann['type']=='protein_coding']['gene_name']))]\n",
    "df = df.reset_index().rename(columns={'genes':'gene'}).set_index('gene', drop = True)\n",
    "all_source, pctsrc, all_targets, pcttgt, summary_LR = ml.lr.find_hits(df,db)\n",
    "reference = reference[reference.index.isin(list(summary_LR['gene']))] # filter reference to only include LRs\n",
    "disease_list = list(reference.columns)\n",
    "iter=1\n",
    "count = 0\n",
    "\n",
    "iter=1\n",
    "count = 0\n",
    "real_LR_intersects = pd.DataFrame(np.zeros(shape=(iter, pow(len(disease_list), 2))))\n",
    "real_LRI_intersects = pd.DataFrame(np.zeros(shape=(iter, pow(len(disease_list), 2))))\n",
    "real_distances = pd.DataFrame(np.zeros(shape=(iter, pow(len(disease_list), 2))))\n",
    "\n",
    "for disease1 in disease_list:\n",
    "    for disease2 in disease_list:\n",
    "            real_LR_intersects.rename(columns = {count : disease1+'/'+disease2}, inplace = True)\n",
    "            real_LRI_intersects.rename(columns = {count : disease1+'/'+disease2}, inplace = True)\n",
    "            real_distances.rename(columns = {count : disease1+'/'+disease2}, inplace = True)\n",
    "            for i in range(0,iter):\n",
    "                # Create random list comparable to each disease\n",
    "                genes_disease1 = pd.DataFrame(reference[reference[disease1]==1].index)\n",
    "                genes_disease2 = pd.DataFrame(reference[reference[disease2]==1].index)\n",
    "\n",
    "                ### How many overlapping LRs do random disease 1 and random disease 2 share?\n",
    "                # Keep only genes with known LR role\n",
    "                genes_disease1 = list(genes_disease1[genes_disease1.isin(list(db['genesymbol_intercell_source'])) | genes_disease1.isin(list(db['genesymbol_intercell_target']))].dropna()['genes'])\n",
    "                genes_disease2 = list(genes_disease2[genes_disease2.isin(list(db['genesymbol_intercell_source'])) | genes_disease2.isin(list(db['genesymbol_intercell_target']))].dropna()['genes'])\n",
    "\n",
    "                # Check intersect of lists, add total number to all_intersects list\n",
    "                LR_intersect = len(list(set(genes_disease1) & set(genes_disease2)))\n",
    "                real_LR_intersects.iloc[i, count] = LR_intersect\n",
    "                \n",
    "                ### How many LRIs do random disease 1 and random disease 2 share?\n",
    "                # Get all LRIs where at least one is linked to diseases \n",
    "                LRs_disease1 = db[['genesymbol_intercell_source','genesymbol_intercell_target']][(db['genesymbol_intercell_source'].isin(list(genes_disease1))) | (db['genesymbol_intercell_target'].isin(list(genes_disease1)))]\n",
    "                LRs_disease2 = db[['genesymbol_intercell_source','genesymbol_intercell_target']][(db['genesymbol_intercell_source'].isin(list(genes_disease2))) | (db['genesymbol_intercell_target'].isin(list(genes_disease2)))]\n",
    "                LRs_disease1 = LRs_disease1.dropna()\n",
    "                LRs_disease2 = LRs_disease2.dropna()\n",
    "                LRs_disease1_list = list(LRs_disease1['genesymbol_intercell_source']+LRs_disease1['genesymbol_intercell_target'])\n",
    "                LRs_disease2_list = list(LRs_disease2['genesymbol_intercell_source']+LRs_disease2['genesymbol_intercell_target'])\n",
    "                \n",
    "                # Check intersect of lists\n",
    "                LRI_intersect = len(list(set(LRs_disease1_list) & set(LRs_disease2_list)))\n",
    "                real_LRI_intersects.iloc[i, count] = LRI_intersect\n",
    "\n",
    "                ### How close are the random LR networks?\n",
    "                # Build an adjacency matrix per disease\n",
    "                unique_LRs_disease1 = pd.DataFrame(pd.concat([LRs_disease1['genesymbol_intercell_source'],LRs_disease1['genesymbol_intercell_target']], axis = 0).unique())\n",
    "                unique_LRs_disease2 = pd.DataFrame(pd.concat([LRs_disease2['genesymbol_intercell_source'],LRs_disease2['genesymbol_intercell_target']], axis = 0).unique())\n",
    "                both_unique = pd.concat([unique_LRs_disease1, unique_LRs_disease2], axis = 0)[0].unique()\n",
    "                # For deltacon comparison, the axes of the adjacency matrix must be the same\n",
    "                adj_LRs_disease1 = pd.DataFrame(np.zeros(shape=(len(both_unique), len(both_unique))), index = both_unique, columns = both_unique)\n",
    "                adj_LRs_disease2 = pd.DataFrame(np.zeros(shape=(len(both_unique), len(both_unique))), index = both_unique, columns = both_unique)\n",
    "                for n in range (0, np.shape(LRs_disease1)[0]):\n",
    "                    adj_LRs_disease1.iloc[adj_LRs_disease1.index.get_loc(LRs_disease1.iloc[n]['genesymbol_intercell_source']), adj_LRs_disease1.columns.get_loc(LRs_disease1.iloc[n]['genesymbol_intercell_target'])] += 1\n",
    "                for n in range (0, np.shape(LRs_disease2)[0]):\n",
    "                    adj_LRs_disease2.iloc[adj_LRs_disease2.index.get_loc(LRs_disease2.iloc[n]['genesymbol_intercell_source']), adj_LRs_disease2.columns.get_loc(LRs_disease2.iloc[n]['genesymbol_intercell_target'])] += 1\n",
    "                if (len(LRs_disease1)<1) or (len(LRs_disease2)<1):\n",
    "                    real_distances.iloc[i, count] = 99\n",
    "                else:\n",
    "                    # Create network and detect communities\n",
    "                    G1 = nx.from_pandas_adjacency(adj_LRs_disease1)\n",
    "                    G2 = nx.from_pandas_adjacency(adj_LRs_disease2)\n",
    "                    # Calculate network distance\n",
    "                    delta = netrd.distance.DeltaCon()\n",
    "                    distance = delta.dist(G1, G2)\n",
    "\n",
    "                    real_distances.iloc[i, count] = distance\n",
    "            count+=1 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "pvals_LR = []\n",
    "pvals_LRI = []\n",
    "pvals_dist = []\n",
    "\n",
    "for pair in list(all_distances.columns):\n",
    "        pvals_LR.append((1+(all_LR_intersects[pair]>=real_LR_intersects[pair][0]).sum())/(12+1))\n",
    "        pvals_LRI.append((1+(all_LRI_intersects[pair]>=real_LRI_intersects[pair][0]).sum())/(12+1))\n",
    "        pvals_dist.append((1+(all_distances[pair]<=real_distances[pair][0]).sum())/(12+1))\n",
    "\n",
    "pd.DataFrame(np.asarray(pvals_LR).reshape(18,18), columns = disease_list, index = disease_list).to_csv('processed_data/02a_bootstrapped_disease_comparisons/pvals_overlapping_LRs.csv')\n",
    "pd.DataFrame(np.asarray(pvals_LRI).reshape(18,18), columns = disease_list, index = disease_list).to_csv('processed_data/02a_bootstrapped_disease_comparisons/pvals_overlapping_LRIs.csv')\n",
    "pd.DataFrame(np.asarray(pvals_dist).reshape(18,18), columns = disease_list, index = disease_list).to_csv('processed_data/02a_bootstrapped_disease_comparisons/pvals_deltacon_distances.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "pvals_LR_df = pd.DataFrame(np.asarray(pvals_LR).reshape(-1,1), index = all_distances.columns)\n",
    "dis_pairs = pd.DataFrame(pvals_LR_df.index.str.split('/', expand = True).to_frame()).reset_index().drop(columns = ['level_0', 'level_1'])\n",
    "\n",
    "pvals_LR_df = pd.DataFrame(np.asarray(pvals_LR).reshape(-1,1), index = all_distances.columns)\n",
    "pvals_LR_df.iloc[list(dis_pairs[dis_pairs[0]!=dis_pairs[1]].index)].to_csv('processed_data/02a_bootstrapped_disease_comparisons/pvals_overlapping_LRs_singlecol.csv')\n",
    "pvals_LRI_df = pd.DataFrame(np.asarray(pvals_LRI).reshape(-1,1), index = all_distances.columns)\n",
    "pvals_LRI_df.iloc[list(dis_pairs[dis_pairs[0]!=dis_pairs[1]].index)].to_csv('processed_data/02a_bootstrapped_disease_comparisons/pvals_overlapping_LRIs_singlecol.csv')\n",
    "pvals_dist_df = pd.DataFrame(np.asarray(pvals_dist).reshape(-1,1), index = all_distances.columns)\n",
    "pvals_dist_df.iloc[list(dis_pairs[dis_pairs[0]!=dis_pairs[1]].index)].to_csv('processed_data/02a_bootstrapped_disease_comparisons/pvals_deltacon_distances_singlecol.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.DataFrame(np.asarray(real_LR_intersects).reshape(18,18), columns = disease_list, index = disease_list).to_csv('processed_data/02a_bootstrapped_disease_comparisons/real_overlapping_LRs_singlecol.csv')\n",
    "pd.DataFrame(np.asarray(real_LRI_intersects).reshape(18,18), columns = disease_list, index = disease_list).to_csv('processed_data/02a_bootstrapped_disease_comparisons/real_overlapping_LRIs_singlecol.csv')\n",
    "pd.DataFrame(np.asarray(real_distances).reshape(18,18), columns = disease_list, index = disease_list).to_csv('processed_data/02a_bootstrapped_disease_comparisons/real_deltacon_distances_singlecol.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "qtls_LR = []\n",
    "qtls_LRI = []\n",
    "qtls_dist = []\n",
    "\n",
    "for pair in list(all_distances.columns):\n",
    "        qtls_LR.append(all_LR_intersects[pair].quantile(0.90)<real_LR_intersects[pair][0])\n",
    "        qtls_LRI.append(all_LRI_intersects[pair].quantile(0.90)<real_LRI_intersects[pair][0])\n",
    "        qtls_dist.append(all_distances[pair].quantile(0.1)>real_distances[pair][0])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x720 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x720 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\melis\\AppData\\Local\\Programs\\Python\\Python37\\lib\\site-packages\\seaborn\\matrix.py:625: ClusterWarning: scipy.cluster: The symmetric non-negative hollow observation matrix looks suspiciously like an uncondensed distance matrix\n",
      "  metric=self.metric)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x720 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualise overlapping LRs\n",
    "g = sns.clustermap(pd.DataFrame(np.asarray(real_LR_intersects).reshape(18,18), columns = disease_list, index = disease_list), vmax = 20, cmap = 'viridis')\n",
    "mask = pd.DataFrame(np.asarray(qtls_LR).reshape(18,18), columns = disease_list, index = disease_list) == True\n",
    "# Get the order of the rows and columns from the clustermap\n",
    "row_order = g.dendrogram_row.reordered_ind\n",
    "col_order = g.dendrogram_col.reordered_ind\n",
    "\n",
    "# Reorder the mask according to the clustermap\n",
    "mask = mask.iloc[row_order, col_order]\n",
    "\n",
    "# Iterate over the data and add a marker for significant p-values\n",
    "for text in g.ax_heatmap.texts:\n",
    "    text.set_visible(False)\n",
    "for i in range(mask.shape[0]):\n",
    "    for j in range(mask.shape[1]):\n",
    "        if mask.iloc[i, j]:\n",
    "            g.ax_heatmap.text(j+0.5, i+0.5, '*', ha='center', va='center', color='black')\n",
    "plt.savefig('plots/02-clustering_with_LR_partners/02b_plot_bootstrapped_disease_comparisons/LR_overlaps_90thpctl.png', bbox_inches = 'tight', dpi = 300)\n",
    "plt.show()\n",
    "\n",
    "# Visualise overlapping LRIs\n",
    "g = sns.clustermap(pd.DataFrame(np.asarray(real_LRI_intersects).reshape(18,18), columns = disease_list, index = disease_list), vmax = 150, cmap = 'viridis')\n",
    "mask = pd.DataFrame(np.asarray(qtls_LRI).reshape(18,18), columns = disease_list, index = disease_list) == True\n",
    "# Get the order of the rows and columns from the clustermap\n",
    "row_order = g.dendrogram_row.reordered_ind\n",
    "col_order = g.dendrogram_col.reordered_ind\n",
    "\n",
    "# Reorder the mask according to the clustermap\n",
    "mask = mask.iloc[row_order, col_order]\n",
    "\n",
    "# Iterate over the data and add a marker for significant p-values\n",
    "for text in g.ax_heatmap.texts:\n",
    "    text.set_visible(False)\n",
    "for i in range(mask.shape[0]):\n",
    "    for j in range(mask.shape[1]):\n",
    "        if mask.iloc[i, j]:\n",
    "            g.ax_heatmap.text(j+0.5, i+0.5, '*', ha='center', va='center', color='black')\n",
    "\n",
    "plt.savefig('plots/02-clustering_with_LR_partners/02b_plot_bootstrapped_disease_comparisons/LRI_overlaps_90thpctl.png', bbox_inches = 'tight', dpi = 300)\n",
    "plt.show()\n",
    "\n",
    "# Visualise Deltacon distances\n",
    "g = sns.clustermap(pd.DataFrame(np.asarray(real_distances).reshape(18,18), columns = disease_list, index = disease_list), cmap = 'viridis_r')\n",
    "mask = pd.DataFrame(np.asarray(qtls_dist).reshape(18,18), columns = disease_list, index = disease_list) == True\n",
    "# Get the order of the rows and columns from the clustermap\n",
    "row_order = g.dendrogram_row.reordered_ind\n",
    "col_order = g.dendrogram_col.reordered_ind\n",
    "\n",
    "# Reorder the mask according to the clustermap\n",
    "mask = mask.iloc[row_order, col_order]\n",
    "\n",
    "# Iterate over the data and add a marker for significant p-values\n",
    "for text in g.ax_heatmap.texts:\n",
    "    text.set_visible(False)\n",
    "for i in range(mask.shape[0]):\n",
    "    for j in range(mask.shape[1]):\n",
    "        if mask.iloc[i, j]:\n",
    "            g.ax_heatmap.text(j+0.5, i+0.5, '*', ha='center', va='center', color='black')\n",
    "plt.savefig('plots/02-clustering_with_LR_partners/02b_plot_bootstrapped_disease_comparisons/deltacon_disease_distances_10thpctl.png', bbox_inches = 'tight', dpi = 300)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}