tutorials/Run_TraSig_on_example_data.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Get started \n",
    "\n",
    "In this tutorial, we will run TraSig on the example data (and trajectory). We will then analyze TraSig's inference results, including calculating the summary interaction score for cell cluster (type) pairs and conducting GO enrichment analysis on the significant ligands and receptors. \n",
    "\n",
    "Alternatively, you may run the script [analyze_outputs.py](analyze_outputs.py) to analyze the outputs from TraSig using the command-line tool. By running this script, you can obtain all analysis outputs, except for the GO enrichment analysis results. Please refer to [Obtain the analysis results using the command-line tool](#2.1) and **Command-line tools** session in README.md for more details.\n",
    "\n",
    "On Dec 2021, we added the alignment option to allow aligning pseudotime trajectories before calculating the interaction scores. We currently support two alignment options: \n",
    "1. aligning using ligands and receptors \n",
    "2. aligning using a customized list of genes\n",
    "\n",
    "For the first option, for each pair of edges, the ligands from the sender edges will be used to align with the receptors from the receiver edges. For the second option, the same genes from both edges will be used for alignment. See **Command-line tools** session in README.md for details on how to use alignment. See also [Prepare_input_from_user_defined_trajectory](Prepare_input_from_user_defined_trajectory.ipynb) for how to prepare inputs if using alignment.\n",
    "\n",
    "**Table of Content**\n",
    "1. [Run TraSig on the example data](#1)  \n",
    "2. [Analyze TraSig results](#2) \n",
    "    1. [(optional) Obtain the analysis results using the command-line tool](#2.1) \n",
    "    2. [Load inputs](#2.2) \n",
    "    3. [Load outputs](#2.3)  \n",
    "    4. [Adjust p-values for multiple comparisons](#2.4) \n",
    "    5. [Infer interactions among cell clusters (edges)](#2.5) \n",
    "    6. [GO analysis](#2.6)  \n",
    "\n",
    "**Extra Package Requirements**   \n",
    "(if you follow the install instructions for TraSig then the following packages should be installed already)\n",
    "* statsmodels >= 0.12.1 (required for post-analysis only)\n",
    "* scipy >= 1.5.4 (required for post-analysis only)\n",
    "* matplotlib >= 3.3.4 (required for post-analysis only)\n",
    "* seaborn >= 0.11.0 (required for post-analysis only)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "import sys\n",
    "import os\n",
    "import gc\n",
    "import requests\n",
    "\n",
    "import numpy as np\n",
    "import bottleneck as bn\n",
    "import pandas as pd\n",
    "\n",
    "# load packages required for analysis \n",
    "import statsmodels.api as sm\n",
    "import statsmodels as sm\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from scipy import stats"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Run TraSig on the example data\n",
    "<a id=1></a>\n",
    "\n",
    "1. The inputs are prepared following the Prepare_input_from_dynverse_ti_methods.ipynb tutorial.\n",
    "2. For the following demo, we run 1e5 permutations using multiprocessing with 8 cores. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Namespace(aRate=0.05, alignType='unaligned', bRate=2.5, errorType='cosine', genePairType='interaction', input='../example/input', listType='ligand_receptor', metric='dot', modelName='ti_slingshot', multiProcess=True, nLap=20, nan2zero=True, ncores='8', numPerms='100000', output='../example/output', overlap=0.5, preprocess='None', project='oligodendrocyte-differentiation-clusters_marques', rate=1, smooth=1, startingTreatment='smallerWindow')\n",
      "Load:  oligodendrocyte-differentiation-clusters_marques_ligand_receptor.txt\n",
      "Permutations grouped to different cores: [range(1, 14286), range(14286, 28571), range(28571, 42856), range(42856, 57141), range(57141, 71426), range(71426, 85711), range(85711, 99996), range(99996, 100001)]\n",
      "CPU times: user 48.5 s, sys: 6.58 s, total: 55 s\n",
      "Wall time: 1h 2min 40s\n"
     ]
    }
   ],
   "source": [
    "%time ! main.py -i ../example/input -o ../example/output -d oligodendrocyte-differentiation-clusters_marques -g None -b ti_slingshot -c 8 -n 100000 -s smallerWindow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Analyze TraSig results\n",
    "<a id=2></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1 (Optional) Obtain the analysis results using the command-line tool\n",
    "<a id=2.1></a>\n",
    "* You can run the following script to obtain all analysis outputs, except for the GO analysis results.\n",
    "* Alternatively, you may follow the break-downs starting from [Load inputs](#2.2) to obtain the analysis outputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Namespace(aRate=0.05, alignType='unaligned', bRate=2.5, errorType='cosine', genePairType='interaction', input='../example/input', listType='ligand_receptor', metric='dot', modelName='ti_slingshot', nLap=20, nan2zero=True, numPerms='100000', otherIdentifier='None', output='../example/output', overlap=0.5, preprocess='None', project='oligodendrocyte-differentiation-clusters_marques', rate=1, smooth=1, startingTreatment='smallerWindow')\n",
      "Load:  oligodendrocyte-differentiation-clusters_marques_ligand_receptor.txt\n",
      "Analysis outputs to be saved at ../example/output/analysis\n",
      "CPU times: user 35.7 ms, sys: 18.6 ms, total: 54.3 ms\n",
      "Wall time: 1.96 s\n"
     ]
    }
   ],
   "source": [
    "%time ! python analyze_outputs.py -i ../example/input -o ../example/output -d oligodendrocyte-differentiation-clusters_marques -g None -p None -b ti_slingshot -p None -n 100000 -s smallerWindow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 Load inputs\n",
    "<a id=2.2></a>\n",
    "\n",
    "* May need to modify the following variables based on your inputs and arguments for TraSig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "project = \"oligodendrocyte-differentiation-clusters_marques\"\n",
    "preprocess = \"None\"\n",
    "model_name = \"ti_slingshot\"\n",
    "others = \"None\"\n",
    "list_type = 'ligand_receptor'\n",
    "startingTreatment = \"smallerWindow\"\n",
    "\n",
    "n_lap = 20 # smoothing window size \n",
    "metrics = ['dot']\n",
    "nan2zero = True\n",
    "num_perms = 1e5\n",
    "\n",
    "align_type = \"unaligned\"\n",
    "\n",
    "if align_type != \"unaligned\":\n",
    "    # here we set these variables to their default values; may need to reset them accordingly\n",
    "    SMOOTH_PARAMETER = float(10)\n",
    "    OVERLAP_THRESHOLD = float(0.5)\n",
    "    SAMPLING_RATE = int(1)\n",
    "    \n",
    "    gene_pair_type = \"interaction\"\n",
    "    \n",
    "    error_type = \"cosine\"\n",
    "    a_rate = float(0.05)\n",
    "    b_rate = float(2.5)\n",
    "    \n",
    "else:\n",
    "    pass\n",
    "\n",
    "\n",
    "# set the path to TraSig's inputs \n",
    "input_path = '../example/input'\n",
    "# set the path to TraSig's outputs; \n",
    "# the analysis outpus will be saved at output_path/analysis\n",
    "output_path = '../example/output'  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Load TraSig's inputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Load:  oligodendrocyte-differentiation-clusters_marques_ligand_receptor.txt\n"
     ]
    }
   ],
   "source": [
    "if preprocess != \"None\":\n",
    "    _preprocess = f\"_{preprocess}\"\n",
    "else:\n",
    "    _preprocess = \"\"\n",
    "    \n",
    "if others == \"None\":\n",
    "    others = \"\"\n",
    "    \n",
    "if startingTreatment != \"None\":\n",
    "    _startingTreatment = f\"_{startingTreatment}\"\n",
    "else:\n",
    "    _startingTreatment = \"\"\n",
    "\n",
    "suffix = f\"{project}_{list_type}{_preprocess}_{model_name}\"\n",
    "suffix = f\"{suffix}{_startingTreatment}_nlap_{n_lap}{others}\"\n",
    "\n",
    "if align_type != \"unaligned\":\n",
    "    suffix = f\"{suffix}_{gene_pair_type}_{SMOOTH_PARAMETER}_{error_type}_{a_rate}_{b_rate}\"\n",
    "else:\n",
    "    pass\n",
    "\n",
    "# get interaction file (list of (ligand, receptor/target))\n",
    "filename = f\"{list_type}_{project}{_preprocess}.pickle\"\n",
    "with open(os.path.join(input_path, filename), 'rb') as handle:\n",
    "    interaction_list = pickle.load(handle)\n",
    "\n",
    "# load expression data\n",
    "filename = f\"{project}{_preprocess}_{list_type}.txt\"\n",
    "if align_type != \"unaligned\" and gene_pair_type != \"interaction\":\n",
    "    filename = f\"{project}{_preprocess}_{list_type}_{gene_pair_type}.txt\"\n",
    "print(\"Load: \", filename)\n",
    "\n",
    "data_file = os.path.join(input_path, filename)\n",
    "df = pd.read_csv(data_file, index_col=0)\n",
    "cell_exps = df.values\n",
    "gene_names = list(df.columns.values)  # assume unique\n",
    "\n",
    "\n",
    "# (optional) load corresponding between sampling time and path\n",
    "filename = f\"sampling_time_per_path_{project}{_preprocess}_{model_name}.pickle\"\n",
    "with open(os.path.join(input_path, filename), 'rb') as handle:\n",
    "    time2path = pickle.load(handle)\n",
    "\n",
    "path2time = dict()\n",
    "for k, ps in time2path.items():\n",
    "    for p in ps:\n",
    "        path2time[p] = k\n",
    "\n",
    "        \n",
    "# load path & time assignment\n",
    "# original assignment\n",
    "hid_var_file = f\"{project}{_preprocess}_{model_name}_it2_hid_var.pickle\"\n",
    "with open(os.path.join(input_path, hid_var_file), 'rb') as handle:\n",
    "    hid_var = pickle.load(handle, encoding=\"latin1\")\n",
    "\n",
    "unique_paths = np.unique(hid_var[\"cell_path\"])\n",
    "all_times = [round(i, 2) for i in np.arange(0, 1.01, 0.01)]  # all possible labels for cell time\n",
    "cell_paths_o = hid_var[\"cell_path\"]\n",
    "cell_times_o = hid_var[\"cell_time\"]\n",
    "\n",
    "# put time (from 0 to 1) into 101 bins\n",
    "cell_times_o = np.round(cell_times_o, 2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.3 Load outputs\n",
    "<a id=2.3></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load the scores on the observed original data \n",
    "_n = 0\n",
    "\n",
    "_columns = dict.fromkeys(metrics)\n",
    "for m in metrics:\n",
    "    _columns[m] = []\n",
    "\n",
    "_columns.update({'pair': [], 'gene_pair_id': []})\n",
    "\n",
    "# load results  \n",
    "filename = f\"{suffix}_metrics_{_n}.pickle\"\n",
    "data_file = os.path.join(output_path, filename)\n",
    "\n",
    "with open(data_file, 'rb') as handle:\n",
    "    results = pickle.load(handle)\n",
    "\n",
    "for pair, mets in results.items():\n",
    "    for m in metrics:\n",
    "        _columns[m] += list(mets[m])\n",
    "\n",
    "    _columns['pair'] += list(np.repeat(pair, len(mets[m])))\n",
    "    _columns['gene_pair_id'] += list(range(len(mets[m])))\n",
    "    \n",
    "df = pd.DataFrame(_columns)\n",
    "num_pairs = len(results[pair][m])\n",
    "\n",
    "\n",
    "# load permutation results  \n",
    "suffix = f\"{suffix}_{int(np.log10(num_perms))}\"\n",
    "if align_type != \"unaligned\":\n",
    "    suffix = f\"{suffix}_{align_type}\"\n",
    "else:\n",
    "    pass\n",
    "\n",
    "child_suffix = f\"{suffix}_{metrics[0]}\"\n",
    "\n",
    "filename = f\"{suffix}_permutation_results.pickle\"\n",
    "data_file = os.path.join(output_path, filename)\n",
    "\n",
    "with open(data_file, 'rb') as handle:\n",
    "    pair2counts = pickle.load(handle)\n",
    "\n",
    "    \n",
    "# turn to p-values\n",
    "for pair, _ in pair2counts.items():\n",
    "    for m in metrics:\n",
    "         pair2counts[pair][m] = (pair2counts[pair][m] + 1)/(num_perms + 1)\n",
    "\n",
    "            \n",
    "# add to the dataframe            \n",
    "_columns = dict.fromkeys(metrics)\n",
    "for m in metrics:\n",
    "    _columns[m] = []\n",
    "\n",
    "for pair, counts in pair2counts.items():\n",
    "    for m in metrics:\n",
    "        _columns[m] += list(counts[m])\n",
    "        \n",
    "for m in metrics:\n",
    "    df[f\"{m}_p\"] = _columns[m]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add ligand target info\n",
    "df['ligand'] = [interaction_list[int(i)][0] for i in df['gene_pair_id']]\n",
    "df['target'] = [interaction_list[int(i)][1] for i in df['gene_pair_id']]\n",
    "ligand_list = np.unique(df['ligand'])\n",
    "\n",
    "# add more info about cell clusters \n",
    "df['sender'] = [i.split('_')[0] for i in df['pair']]\n",
    "df['receiver'] = [i.split('_')[1] for i in df['pair']]\n",
    "df['sender'] = df['sender'].astype('int')\n",
    "df['receiver'] = df['receiver'].astype('int')\n",
    "df['time-sender'] = [path2time[i] for i in df['sender']]\n",
    "df['time-receiver'] = [path2time[i] for i in df['receiver']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### label clusters using the true labels of the majority of cells (for plotting)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "------current path 0\n",
      "MOL 0.72\n",
      "0.97\n",
      "------current path 1\n",
      "NFOL 0.75\n",
      "0.92\n",
      "------current path 2\n",
      "MOL 1.0\n",
      "------current path 3\n",
      "MOL 1.0\n"
     ]
    }
   ],
   "source": [
    "# build path2label\n",
    "\n",
    "unique_days = np.unique(hid_var['cell_labels'])\n",
    "cell_paths = np.unique(hid_var[\"cell_path\"])\n",
    "\n",
    "_dict = dict.fromkeys(range(len(cell_paths)))  \n",
    "\n",
    "for i, cur_path in enumerate(cell_paths):\n",
    "    print(\"------current path\", cur_path)\n",
    "    \n",
    "    # get data corresponding to a path\n",
    "    condition = hid_var[\"cell_path\"] == cur_path\n",
    "    cur_labels = hid_var['cell_labels'][condition]\n",
    "    try:\n",
    "        cur_labels = [i.decode('UTF-8') for i in cur_labels]\n",
    "    except AttributeError:\n",
    "        pass \n",
    "    \n",
    "    # get the sampling time for the majority cells \n",
    "    mode, count = stats.mode(cur_labels)\n",
    "    \n",
    "    major_percent = round(float(count[0])/len(cur_labels), 2)\n",
    "    print(mode[0], major_percent)\n",
    "    \n",
    "    cur_label = mode[0]\n",
    "    \n",
    "    # add more labels if cells of the major cell type make less than 90% of the whole population \n",
    "    if  major_percent < 0.9:\n",
    "        cur_label += '(' + str(major_percent) + ')'\n",
    "        \n",
    "        labels, counts = np.unique(cur_labels, return_counts=True)\n",
    "        sorted_counts, idxs = np.unique(counts, return_index=True)\n",
    "       #  print(zip(sorted_counts, labels[idxs]))\n",
    "        \n",
    "        count = 0\n",
    "        while major_percent < 0.9:\n",
    "            # add more labels until major_percent >= 0.9\n",
    "            add_counts = sorted_counts[::-1][1+count]\n",
    "            _add_percent = round(add_counts/len(cur_labels), 2)\n",
    "    \n",
    "            major_percent += _add_percent\n",
    "            print(major_percent)\n",
    "            \n",
    "            cur_label += '\\n '\n",
    "            cur_label += labels[idxs][::-1][1+count]\n",
    "            cur_label += '(' + str(round(_add_percent, 2)) + ')'\n",
    "            \n",
    "            count += 1\n",
    "    \n",
    "    _dict[cur_path] = cur_label\n",
    "    \n",
    "path2label = _dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.4 Adjust p-values for multiple comparisons\n",
    "<a id=2.4></a>\n",
    "\n",
    "Here we use the BH procedure to control the FDR rate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "_p = df['dot_p'].values.copy()\n",
    "\n",
    "for pair in results.keys(): \n",
    "    condition = np.where(df['pair'] == pair)[0]\n",
    "    adjusted = sm.stats.multitest.fdrcorrection(df['dot_p'].values[condition])\n",
    "    _p[condition] = adjusted[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['dot_p_adjusted'] = _p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>pair</th>\n",
       "      <th>sender</th>\n",
       "      <th>receiver</th>\n",
       "      <th>time-sender</th>\n",
       "      <th>time-receiver</th>\n",
       "      <th>gene_pair_id</th>\n",
       "      <th>ligand</th>\n",
       "      <th>target</th>\n",
       "      <th>dot</th>\n",
       "      <th>dot_p</th>\n",
       "      <th>dot_p_adjusted</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0_0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>ADAM17</td>\n",
       "      <td>NOTCH1</td>\n",
       "      <td>0.242648</td>\n",
       "      <td>0.000680</td>\n",
       "      <td>0.001587</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0_0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>AGRN</td>\n",
       "      <td>ATP1A3</td>\n",
       "      <td>0.668552</td>\n",
       "      <td>0.000120</td>\n",
       "      <td>0.000931</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0_0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>AGRP</td>\n",
       "      <td>SDC3</td>\n",
       "      <td>0.008098</td>\n",
       "      <td>0.005690</td>\n",
       "      <td>0.012122</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0_0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>APOE</td>\n",
       "      <td>LRP1</td>\n",
       "      <td>1.583651</td>\n",
       "      <td>0.000050</td>\n",
       "      <td>0.000931</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0_0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "      <td>APOE</td>\n",
       "      <td>SORL1</td>\n",
       "      <td>0.200087</td>\n",
       "      <td>0.171918</td>\n",
       "      <td>0.210600</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  pair  sender  receiver  time-sender  time-receiver  gene_pair_id  ligand  \\\n",
       "0  0_0       0         0            0              0             0  ADAM17   \n",
       "1  0_0       0         0            0              0             1    AGRN   \n",
       "2  0_0       0         0            0              0             2    AGRP   \n",
       "3  0_0       0         0            0              0             3    APOE   \n",
       "4  0_0       0         0            0              0             4    APOE   \n",
       "\n",
       "   target       dot     dot_p  dot_p_adjusted  \n",
       "0  NOTCH1  0.242648  0.000680        0.001587  \n",
       "1  ATP1A3  0.668552  0.000120        0.000931  \n",
       "2    SDC3  0.008098  0.005690        0.012122  \n",
       "3    LRP1  1.583651  0.000050        0.000931  \n",
       "4   SORL1  0.200087  0.171918        0.210600  "
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "columns = ['pair','sender', 'receiver', 'time-sender', 'time-receiver', 'gene_pair_id', \n",
    "           'ligand', 'target', 'dot', 'dot_p', 'dot_p_adjusted']\n",
    "\n",
    "df[columns].head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.5 Infer interactions among cell clusters (edges)\n",
    "<a id=2.5></a>\n",
    "\n",
    "For each cluster pair, using the results for ligand-receptors, we infer the overall interacting score by counting how many of the ligand-receptors are significant. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# reset output path to save analysis results\n",
    "output_path = f\"{output_path}/analysis\"\n",
    "\n",
    "if not os.path.exists(output_path):\n",
    "    os.makedirs(output_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculate summary score over all ligand-receptor pairs "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_pool = pd.DataFrame(list(set(df['pair'])))\n",
    "df_pool.columns = ['pair']\n",
    "\n",
    "df_pool['sender'] = [i.split('_')[0] for i in df_pool['pair']]\n",
    "df_pool['receiver'] = [i.split('_')[1] for i in df_pool['pair']]\n",
    "df_pool['sender'] = df_pool['sender'].astype('int')\n",
    "df_pool['receiver'] = df_pool['receiver'].astype('int')\n",
    "df_pool['time-sender'] = [path2time[i] for i in df_pool['sender']]\n",
    "df_pool['time-receiver'] = [path2time[i] for i in df_pool['receiver']]\n",
    "# df_pool = df_pool[df_pool['time-sender'] == df_pool['time-receiver']]  # if only keep pairs sampled at the same time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "cutoff =  0.05\n",
    "name_p = 'dot_p_adjusted'\n",
    "\n",
    "_counts = []\n",
    "for p in df_pool['pair']:\n",
    "    condition = df['pair'] == p\n",
    "    _counts.append((df[condition][name_p] < cutoff).sum())\n",
    "    \n",
    "df_pool['counts'] = _counts\n",
    "\n",
    "# subset only contains significant pairs\n",
    "condition = df[name_p] < cutoff\n",
    "df_sig = df[condition].copy()\n",
    "df_sig.reset_index(inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# order clusters (edges / paths) by sampling time \n",
    "path_order_time = []\n",
    "for k, v in time2path.items():\n",
    "    path_order_time = path_order_time + v\n",
    "\n",
    "df_pool['sender'] = pd.Categorical(df_pool['sender'], path_order_time)\n",
    "df_pool['receiver'] = pd.Categorical(df_pool['receiver'], path_order_time)\n",
    "df_pool.sort_values(['sender', 'receiver'], inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "_vmin = min(df_pool['counts'])\n",
    "_vmax = max(df_pool['counts'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "method = \"TraSig\"\n",
    "metric = 'counts'\n",
    "\n",
    "_center_value = _vmin\n",
    "# plot only pairs sampled at the same time \n",
    "df_plot = df_pool[df_pool['time-sender'] == df_pool['time-receiver']].pivot(index='sender', columns='receiver', values=metric)\n",
    "\n",
    "# sort by column names\n",
    "df_plot = df_plot.sort_index(axis=1)\n",
    "\n",
    "# sns.set_style(\"white\")\n",
    "plt.figure(figsize=(5, 5))\n",
    "sns.set_context(\"paper\", font_scale=2) \n",
    "\n",
    "ax = sns.heatmap(df_plot.values, xticklabels=True, yticklabels=True,\n",
    "                     vmin=_vmin, vmax=_vmax, center=_center_value, cmap=\"RdBu_r\")\n",
    "\n",
    "plt.xticks(rotation=90)\n",
    "plt.ylabel(\"Sender\")\n",
    "plt.xlabel('Receiver')\n",
    "ax.set_xticklabels(df_plot.index.values)\n",
    "ax.set_yticklabels(df_plot.index.values)\n",
    "\n",
    "if 'tf' in model_name:\n",
    "    _traj = 'CSHMM'\n",
    "    plt.title(f\"{method} using \\n output from {_traj}\")\n",
    "else:\n",
    "    _traj = model_name.split('_')[1].capitalize()\n",
    "    plt.title(f\"{method} using \\n output from {_traj}\")\n",
    "\n",
    "filename = f\"{child_suffix}_summary_scores.png\"\n",
    "plt.savefig(os.path.join(output_path, filename), bbox_inches=\"tight\", dpi=300, format=\"png\")\n",
    "filename = f\"{child_suffix}_summary_scores.eps\"\n",
    "plt.savefig(os.path.join(output_path, filename), bbox_inches=\"tight\", dpi=300, format=\"eps\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### save summary score "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_pool['sender-label'] = df_pool['sender'].replace(path2label)\n",
    "df_pool['receiver-label'] = df_pool['receiver'].replace(path2label)\n",
    "\n",
    "cols_order = ['sender', 'sender-label', 'receiver', 'receiver-label', 'counts']\n",
    "df_out = df_pool[cols_order].copy()\n",
    "\n",
    "filename = f\"{child_suffix}_summary_score.csv\"\n",
    "df_out.to_csv(os.path.join(output_path, filename), index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### save significant ligand-receptor pairs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_sig['sender-label'] = df_sig['sender'].replace(path2label)\n",
    "df_sig['receiver-label'] = df_sig['receiver'].replace(path2label)\n",
    "\n",
    "# sort ligand-receptors in each cluster pair by their scores \n",
    "_dfs =[] \n",
    "pairs_ts = np.unique(df_sig['pair'])\n",
    "for pair in pairs_ts:\n",
    "    condition = df_sig['pair'] == pair\n",
    "    _dfs.append(df_sig[condition].sort_values('dot', ascending=False))\n",
    "    \n",
    "df_sorted = pd.concat(_dfs)\n",
    "cols_order = ['pair', 'time-sender','sender','sender-label','time-receiver', 'receiver','receiver-label', 'ligand', 'target', \\\n",
    "              'dot', 'dot_p', 'dot_p_adjusted']\n",
    "df_sorted = df_sorted[cols_order]\n",
    "\n",
    "\n",
    "df_sorted.columns = ['interaction pair' ,'sender sampling time', 'sender','sender-label','receiver sampling time','receiver','receiver-label', 'ligand', 'target', \n",
    "                   'score', 'score p-value', 'score p-value adjusted']\n",
    "\n",
    "filename = f\"{child_suffix}_significant_pairs.csv\"\n",
    "df_sorted.to_csv(os.path.join(output_path, filename), index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.6 GO enrichment analysis\n",
    "<a id=2.6></a>\n",
    "\n",
    "For selected cluster pairs, we use the significant ligands and receptors to conduct GO enrichment analysis. Here we perform the analysis on all interactions acting on either cluster 0 or 1, as an example. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# select interacting pairs for GO analysis\n",
    "pairs_dict = {\"0\": [\"0_0\", \"1_0\", \"2_0\", \"3_0\"], \"1\": [\"0_1\", \"1_1\", \"2_1\", \"3_1\"]}\n",
    "\n",
    "# create the varaible with both ligand and receptor name \n",
    "df_sig['lr'] = [f\"{df_sig['ligand'][i]}_{df_sig['target'][i]}\"for i in range(df_sig.shape[0])]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get enriched GO terms using gProfiler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getGO(input_genes, out_file_name=None, save2file=False):\n",
    "    \"\"\"\n",
    "    Modified based on output analysis in CSHMM.\n",
    "    \n",
    "    Author: Chieh Lin\n",
    "    Link to original code: https://github.com/jessica1338/CSHMM-for-time-series-scRNA-Seq/blob/master/CSHMM_analysis.py\n",
    "    \n",
    "    \"\"\"\n",
    "\n",
    "    r = requests.post(\n",
    "            url = 'https://biit.cs.ut.ee/gprofiler/api/gost/profile/',\n",
    "            json = {\n",
    "                'organism':species,\n",
    "                'query':list(input_genes),\n",
    "                }\n",
    "        )\n",
    "\n",
    "\n",
    "    if \"result\" not in r.json():\n",
    "        return \n",
    "\n",
    "    res = r.json()['result']\n",
    "    if len(res) > 0:\n",
    "        columns = res[0].keys()\n",
    "        out_df = pd.DataFrame()\n",
    "        for col in columns:\n",
    "            if col == \"intersections\":\n",
    "                continue\n",
    "            tmp = [r[col] for r in res]\n",
    "            out_df[col] = tmp\n",
    "            \n",
    "        if save2file and out_file_name is not None: \n",
    "            out_df.to_csv(out_file_name, sep=\"\\t\", index=False, encoding=\"utf-8\")\n",
    "            \n",
    "        return out_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a helper function\n",
    "flatten = lambda t: [item for sublist in t for item in sublist]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of genes used for searching for 0_0: 37\n",
      "Number of genes used for searching for 1_0: 41\n",
      "Number of genes used for searching for 2_0: 24\n",
      "Number of genes used for searching for 3_0: 41\n",
      "Number of genes used for searching for 0_1: 39\n",
      "Number of genes used for searching for 1_1: 36\n",
      "Number of genes used for searching for 2_1: 27\n",
      "Number of genes used for searching for 3_1: 36\n"
     ]
    }
   ],
   "source": [
    "species = \"mmusculus\"\n",
    "# species = \"hsapiens\"\n",
    "read_saved = False\n",
    "\n",
    "go_results = dict.fromkeys(pairs_dict.keys())\n",
    "\n",
    "for cur_cell_type in [\"0\", \"1\"]:\n",
    "    all_pairs = pairs_dict[cur_cell_type]\n",
    "    \n",
    "    all_out_dfs = []\n",
    "    for i in range(len(all_pairs)):\n",
    "        pair = all_pairs[i]\n",
    "\n",
    "        filename = f\"GO_{pair}_{child_suffix}.csv\"\n",
    "        directory = f\"{output_path}/GO_analysis\"\n",
    "        if not os.path.exists(directory):\n",
    "            os.makedirs(directory)\n",
    "\n",
    "        out_file_name = f\"{directory}/{filename}\"\n",
    "\n",
    "        if read_saved:\n",
    "            out_df = pd.read_csv(out_file_name, sep='\\t')\n",
    "        else:\n",
    "            _lrs_tg = set(df_sig[df_sig['pair'] == pair]['lr'].values)\n",
    "            _lrs_flat_tg = set(flatten([i.split(\"_\") for i in _lrs_tg]))\n",
    "            input_genes = list(_lrs_flat_tg)\n",
    "\n",
    "            print(f\"Number of genes used for searching for {pair}: {len(input_genes)}\")\n",
    "\n",
    "            out_df = getGO(input_genes, out_file_name=out_file_name, save2file=True)\n",
    "\n",
    "        if out_df is not None:\n",
    "            all_out_dfs.append(out_df)\n",
    "            \n",
    "    go_results[cur_cell_type] = all_out_dfs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### analysis on enrichment results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def findGOterms(keywords, goprofile_results, all_pairs):\n",
    "    _terms = []\n",
    "    used_keywords = []\n",
    "    \n",
    "    for k in range(len(all_pairs)):\n",
    "        try:\n",
    "            for i in goprofile_results[k]['name']:\n",
    "                for j in keywords:\n",
    "                    if j in i.split(' '):\n",
    "                        _terms.append(i)\n",
    "                        used_keywords.append(j)\n",
    "        except IndexError:\n",
    "            continue\n",
    "            \n",
    "    _terms = list(np.unique(_terms))\n",
    "    \n",
    "    return _terms, used_keywords"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_dev_terms = []\n",
    "\n",
    "for cur_go_results_name, cur_go_results  in go_results.items():\n",
    "    \n",
    "    # find development related terms\n",
    "    keywords = ['Development','development','regeneration','morphogenesis', 'formation', \"differentiation\",\n",
    "               \"migration\", 'localization', 'locomotion', 'motility', 'movement', 'developmental', 'multicellular']\n",
    "    results, used_dev = findGOterms(keywords, cur_go_results, all_pairs)\n",
    "    all_dev_terms += results \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "terms_sets = {'development':np.unique(all_dev_terms)}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### plot GO analysis results for selected terms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "cur_go_names = 'development'\n",
    "cur_go_terms = terms_sets[cur_go_names]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "_max = 0\n",
    "_min = 1e2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_plots = dict.fromkeys(go_results.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "for cur_go_results_name, cur_go_results  in go_results.items():\n",
    "    _ps = []\n",
    "    _terms = []\n",
    "    _pairs = []\n",
    "    \n",
    "    all_pairs = pairs_dict[cur_go_results_name]\n",
    "    \n",
    "    for _term in cur_go_terms:\n",
    "        for i in range(len(all_pairs)):\n",
    "            pair = all_pairs[i]\n",
    "            cur_df = cur_go_results[i]\n",
    "\n",
    "            if _term in cur_df['name'].values:\n",
    "                _p = cur_df['p_value'][cur_df['name'] == _term].values[0]\n",
    "            else: \n",
    "                _p = np.nan\n",
    "\n",
    "            _ps.append(_p)\n",
    "            _terms.append(_term)\n",
    "            _pairs.append(pair)\n",
    "            \n",
    "    df_summary = pd.DataFrame([_pairs,_terms,_ps]).T\n",
    "    \n",
    "    df_summary.columns = ['interacting pair', 'GO term', 'p-value']\n",
    "    df_summary['log10p'] = - np.log10(df_summary['p-value'].astype('float').values)\n",
    "    \n",
    "    df_summary.sort_values('GO term', inplace=True)\n",
    "    df_plot = df_summary.pivot(index='GO term', columns='interacting pair', values='log10p')\n",
    "    \n",
    "    if df_summary['log10p'].max() > _max:\n",
    "        _max = df_summary['log10p'].max()\n",
    "    \n",
    "    if df_summary['log10p'].min() < _min:\n",
    "        _min = df_summary['log10p'].min()\n",
    "    \n",
    "    df_plots[cur_go_results_name] = df_plot[all_pairs]\n",
    "   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### filter to display only highly significant ones\n",
    "1. keep only terms with minimum p-value among all interacting pairs below some cutoff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convert2p(vals):\n",
    "    \"\"\"\n",
    "    Convert -log10(p) back to p.\n",
    "    \"\"\"\n",
    "    return np.power(10, -vals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "results = []\n",
    "\n",
    "for k, v in df_plots.items():\n",
    "    results.append(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "temp = pd.concat(results, axis=1)\n",
    "temp['GO'] = temp.index\n",
    "_max_all_methods = temp.max(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cutoff p-value: 2.152599861968056e-12\n"
     ]
    }
   ],
   "source": [
    "cutoff = np.quantile(_max_all_methods, 0.9)\n",
    "print(f\"Cutoff p-value: {convert2p(cutoff)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# filter GO terms \n",
    "cur_go_terms = temp['GO'][_max_all_methods > cutoff].values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_plots = dict.fromkeys(go_results.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "_max = 0\n",
    "_min = 1e2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "for cur_go_results_name, cur_go_results  in go_results.items():\n",
    "    _ps = []\n",
    "    _terms = []\n",
    "    _pairs = []\n",
    "    \n",
    "    all_pairs = pairs_dict[cur_go_results_name]\n",
    "    \n",
    "    for _term in cur_go_terms:\n",
    "        for i in range(len(all_pairs)):\n",
    "            pair = all_pairs[i]\n",
    "            cur_df = cur_go_results[i]\n",
    "\n",
    "            if _term in cur_df['name'].values:\n",
    "                _p = cur_df['p_value'][cur_df['name'] == _term].values[0]\n",
    "            else: \n",
    "                _p = np.nan\n",
    "\n",
    "            _ps.append(_p)\n",
    "            _terms.append(_term)\n",
    "            _pairs.append(pair)\n",
    "            \n",
    "    df_summary = pd.DataFrame([_pairs,_terms,_ps]).T\n",
    "    \n",
    "    df_summary.columns = ['interacting pair', 'GO term', 'p-value']\n",
    "    df_summary['log10p'] = - np.log10(df_summary['p-value'].astype('float').values)\n",
    "    \n",
    "    df_summary.sort_values('GO term', inplace=True)\n",
    "    df_plot = df_summary.pivot(index='GO term', columns='interacting pair', values='log10p')\n",
    "    \n",
    "    if df_summary['log10p'].max() > _max:\n",
    "        _max = df_summary['log10p'].max()\n",
    "    \n",
    "    if df_summary['log10p'].min() < _min:\n",
    "        _min = df_summary['log10p'].min()\n",
    "    \n",
    "    df_plots[cur_go_results_name] = df_plot[all_pairs]\n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_plots_names = list(df_plots.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "_vmin = _min\n",
    "_vmax = _max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x648 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "portrait = False\n",
    "cmaps = [\"RdBu_r\",'PiYG', 'PRGn', 'BrBG', 'PuOr', 'RdGy', 'RdBu',\n",
    "            'RdYlBu', 'RdYlGn', 'Spectral', 'coolwarm', 'bwr', 'seismic']\n",
    "palettes = cmaps[0]\n",
    "\n",
    "sns.set_context(\"paper\", font_scale=2) \n",
    "\n",
    "SMALL_SIZE = 12\n",
    "MEDIUM_SIZE = 18\n",
    "BIGGER_SIZE = 20\n",
    "\n",
    "rotation_r = 0\n",
    "rotation_c = 45\n",
    "\n",
    "if portrait:\n",
    "    fig, axes = plt.subplots(2,1,figsize=(10,17), gridspec_kw={'height_ratios': [1,1]})  # portrait \n",
    "else:\n",
    "    fig, axes = plt.subplots(1,2,figsize=(12, 9), gridspec_kw={'width_ratios': [1,1.3]})\n",
    "\n",
    "\n",
    "for i in range(len(df_plots_names)):\n",
    "    ax = axes[i]\n",
    "    \n",
    "    _name = df_plots_names[i]\n",
    "    \n",
    "    if portrait:\n",
    "        df_plot = df_plots[_name].T\n",
    "    else:\n",
    "        df_plot = df_plots[_name]\n",
    "    \n",
    "    if portrait == True:\n",
    "        cbar = True\n",
    "    else:\n",
    "        if i == len(df_plots_names) - 1:\n",
    "            cbar = True\n",
    "        else:\n",
    "            cbar = False\n",
    "\n",
    "    sns.heatmap(df_plot, xticklabels=True, yticklabels=True,\n",
    "                         ax = ax, vmax=_vmax, vmin=_vmin, cbar=cbar,center=0,cmap=palettes)\n",
    "    \n",
    "    if portrait:\n",
    "        ax.set_xlabel('')\n",
    "        if i != 2:\n",
    "            ax.xaxis.set_major_locator(plt.NullLocator())\n",
    "        else:\n",
    "            ax.set_xticklabels(ax.get_xticklabels(), rotation=rotation_c, horizontalalignment='right')\n",
    "            \n",
    "        ax.set_yticklabels(ax.get_yticklabels(), rotation=rotation_r, horizontalalignment='right')\n",
    "\n",
    "    else:\n",
    "        ax.set_ylabel('')\n",
    "        if i != 0:\n",
    "            ax.yaxis.set_major_locator(plt.NullLocator())\n",
    "        else:\n",
    "            ax.set_yticklabels(ax.get_yticklabels(), rotation=0, horizontalalignment='right')\n",
    "            \n",
    "        ax.set_xticklabels(ax.get_xticklabels(), rotation=rotation_c, horizontalalignment='right')\n",
    "        \n",
    "    if i != 1:\n",
    "        ax.set_xlabel('') \n",
    "\n",
    "fig.tight_layout(pad=0.01)\n",
    " \n",
    "for i in range(len(df_plots_names)):\n",
    "    _name= path2label[int(df_plots_names[i])]\n",
    "    ax_main = axes[i]\n",
    "    \n",
    "    bbox = ax_main.get_window_extent().transformed(fig.dpi_scale_trans.inverted())\n",
    "    width, height = bbox.width, bbox.height\n",
    "    if portrait:\n",
    "        text = ax_main.text(width+27.7, 3, _name, size=SMALL_SIZE, horizontalalignment='left',\n",
    "                       verticalalignment='top', rotation=270)   \n",
    "    else:\n",
    "        text = ax_main.text(width/2 - 1,  -1.5, _name, size=SMALL_SIZE, horizontalalignment='left',\n",
    "                       verticalalignment='top', rotation=0)\n",
    "    \n",
    "\n",
    "filename = f\"GO_summary_log10p_{child_suffix}_{cur_go_names}.png\"\n",
    "plt.savefig(os.path.join(output_path, filename),dpi=300, bbox_inches = \"tight\", format='png')\n",
    "\n",
    "filename = f\"GO_summary_log10p_{child_suffix}_{cur_go_names}.eps\"\n",
    "plt.savefig(os.path.join(output_path, filename), bbox_inches = \"tight\", dpi=300,  format='eps')\n",
    "plt.show()\n",
    "plt.close()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:spatem]",
   "language": "python",
   "name": "conda-env-spatem-py"
  },
  "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.6.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}