code/07.Permutation-Analysis-LRs.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cell2cell as c2c\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import matplotlib as mlp\n",
    "\n",
    "from cci_distance_correlation import get_correlation\n",
    "\n",
    "from tqdm import tqdm\n",
    "from sklearn.utils import shuffle\n",
    "\n",
    "import json\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Analysis Setup\n",
    "\n",
    "Here, all inputs and parameters needed for the analysis are defined"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Location of files**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_folder = '../data/'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "output_folder = '../results/GA-Permutation/'\n",
    "if not os.path.isdir(output_folder):\n",
    "    os.mkdir(output_folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "files = dict()\n",
    "files['rnaseq'] = data_folder + '/RNA-Seq/Celegans_RNASeqData_Cell.xlsx'\n",
    "files['metadata'] = data_folder + '/RNA-Seq/Celegans_cell_metadata.tsv'\n",
    "files['ppi'] = data_folder + '/PPI-Networks/Celegans-Curated-LR-pairs.xlsx'\n",
    "files['output_folder'] = output_folder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**RNA-seq data manipulation**\n",
    "\n",
    "- <font color=\"green\">'gene_col'</font> is the name of the column containing the list or names of genes in the dataset.\n",
    "- <font color=\"green\">'drop_nangenes'</font> is a boolean decision to remove genes with NaN values.\n",
    "- <font color=\"green\">'log_transform'</font> is a boolean decision to log-transform the dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "rnaseq_setup = dict()\n",
    "rnaseq_setup['gene_col'] = 'gene_id'\n",
    "rnaseq_setup['drop_nangenes'] = True\n",
    "rnaseq_setup['log_transform'] = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Metadata columns**\n",
    "\n",
    "- <font color=\"green\">'sample_col'</font> is the name of the column containing the sample or cell names in RNA-seq data (equivalent to the columns in rnaseq_data).\n",
    "- <font color=\"green\">'group_col'</font> is the name of the column containing the labels for the respective samples or cells in order to group/color them in downstream analyses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "meta_setup = dict()\n",
    "meta_setup['sample_col'] = '#SampleID'\n",
    "meta_setup['group_col'] = 'Groups'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Columns for PPI network**\n",
    "\n",
    "- <font color=\"green\">'protein_cols'</font> is a list containing the names of the first and second interactors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "ppi_setup = dict()\n",
    "ppi_setup['protein_cols'] = ['Ligand_WB', 'Receptor_WB']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Cutoffs setup for binarizing gene expression**\n",
    "\n",
    "- <font color=\"green\">'type'</font> is the type of cutoff to use. \n",
    "    - 'constant_value'\n",
    "    - 'local_percentile'\n",
    "    - 'global_percentile'\n",
    "    - None\n",
    "- <font color=\"green\">'parameter'</font> is the corresponding parameter for the type of cutoff. If percentile is used, it should be a value between 0 and 1. E.g. a value of 0.75 represents the 75-th percentile, and the cutoff to binarize the gene expression will be that value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "cutoff_setup = dict()\n",
    "cutoff_setup['type'] = 'constant_value'\n",
    "cutoff_setup['parameter'] = 10 # TPM"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**General Analysis setups**\n",
    "\n",
    "- <font color=\"green\">'communication_score'</font> is the type of communication score used to detect active pathways between each pair of cell. It can be:\n",
    "    - 'expression_thresholding'\n",
    "    - 'expression_product'\n",
    "    - 'expression_correlation'\n",
    "    - 'differential_combinations'\n",
    "- <font color=\"green\">'cci_score'</font> is the scoring function to aggregate the communication scores. It can be:\n",
    "    - 'bray_curtis'\n",
    "    - 'jaccard'\n",
    "    - 'count'\n",
    "- <font color=\"green\">'cci_type'</font> is the type of interaction between two cells. If it is undirected, ligand and receptor are considered from both cells. If it is directed, ligands from one cell and receptors from the other are considered separately with respect to ligands from the second cell and receptor from the first one. So, it can be:\n",
    "    - 'undirected'\n",
    "    - 'directed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "analysis_setup = dict()\n",
    "analysis_setup['communication_score'] = 'expression_thresholding'\n",
    "analysis_setup['cci_score'] = 'bray_curtis'\n",
    "analysis_setup['cci_type'] = 'undirected'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**RNA-seq**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Opening RNAseq datasets from ../Data//RNA-Seq/Celegans_RNASeqData_Cell.xlsx\n",
      "../Data//RNA-Seq/Celegans_RNASeqData_Cell.xlsx was correctly loaded\n"
     ]
    }
   ],
   "source": [
    "rnaseq_data = c2c.io.load_rnaseq(rnaseq_file=files['rnaseq'],\n",
    "                                 gene_column=rnaseq_setup['gene_col'],\n",
    "                                 drop_nangenes=rnaseq_setup['drop_nangenes'],\n",
    "                                 log_transformation=rnaseq_setup['log_transform'],\n",
    "                                 format='auto')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Metadata for cell types**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "../Data//RNA-Seq/Celegans_cell_metadata.tsv was correctly loaded\n"
     ]
    }
   ],
   "source": [
    "meta = c2c.io.load_metadata(metadata_file=files['metadata'],\n",
    "                            cell_labels=rnaseq_data.columns,\n",
    "                            format='auto')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**PPI network**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Opening PPI datasets from ../Data//PPI-Networks/Celegans-Curated-LR-pairs.xlsx\n",
      "../Data//PPI-Networks/Celegans-Curated-LR-pairs.xlsx was correctly loaded\n",
      "Removing bidirectionality of PPI network\n",
      "Simplying PPI network\n"
     ]
    }
   ],
   "source": [
    "original_ppi_data = c2c.io.load_ppi(ppi_file=files['ppi'],\n",
    "                                    interaction_columns=ppi_setup['protein_cols'],\n",
    "                                    rnaseq_genes=list(rnaseq_data.index),\n",
    "                                    format='auto')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PPI data has 245 PPIs\n",
      "Number of Ligands: 127\n",
      "Number of Receptors: 66\n"
     ]
    }
   ],
   "source": [
    "print('PPI data has {} PPIs'.format(len(original_ppi_data)))\n",
    "print('Number of Ligands: {}'.format(original_ppi_data.A.unique().shape[0]))\n",
    "print('Number of Receptors: {}'.format(original_ppi_data.B.unique().shape[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Opening PPI datasets from ../Data//PPI-Networks/Celegans-GA-Selected-LR-pairs.csv\n",
      "../Data//PPI-Networks/Celegans-GA-Selected-LR-pairs.csv was correctly loaded\n",
      "Removing bidirectionality of PPI network\n",
      "Simplying PPI network\n"
     ]
    }
   ],
   "source": [
    "ppi_data = c2c.io.load_ppi(data_folder + '/PPI-Networks/Celegans-GA-BrayCurtis-Selected-LR-pairs.csv',\n",
    "                           interaction_columns=ppi_setup['protein_cols'],\n",
    "                           rnaseq_genes=list(rnaseq_data.index),\n",
    "                           format='auto')\n",
    "ppi_data = ppi_data.drop_duplicates()\n",
    "ppi_data.reset_index(inplace=True, drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PPI data has 37 PPIs\n",
      "Number of Ligands: 30\n",
      "Number of Receptors: 29\n"
     ]
    }
   ],
   "source": [
    "print('PPI data has {} PPIs'.format(len(ppi_data)))\n",
    "print('Number of Ligands: {}'.format(ppi_data.A.unique().shape[0]))\n",
    "print('Number of Receptors: {}'.format(ppi_data.B.unique().shape[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Phenotype**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "../Data//Digital-3D-Map/Celegans_Physical_Distances_Min.csv was correctly loaded\n"
     ]
    }
   ],
   "source": [
    "physical_distance = c2c.io.load_table(data_folder + '/Digital-3D-Map/Celegans_Physical_Distances_Min.csv',\n",
    "                                          **{'index_col' : 0})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Run Analysis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Cells to include**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "manually_excluded = [\n",
    "                     #'Germline'\n",
    "                    ]\n",
    "included_cells = sorted(list((set(rnaseq_data.columns) & set(physical_distance.columns) - set(manually_excluded))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Permutation of Ligands or Receptors (independently)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "corr_dist = {'permutation' : dict(),\n",
    "             'label_switching' : dict() \n",
    "            } # A: Ligand; B: Receptor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "permu_number = 9999"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Permutate Ligands**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████| 9999/9999 [16:58<00:00,  9.82it/s]\n"
     ]
    }
   ],
   "source": [
    "shuffle_col = 'A'\n",
    "corr_dist['permutation'][shuffle_col] = []\n",
    "\n",
    "for i in tqdm(range(permu_number)):\n",
    "    shuffled_ppi_data = c2c.preprocessing.shuffle_cols_in_df(ppi_data, shuffle_col, random_state=i)\n",
    "    bi_ppi_data = c2c.preprocessing.bidirectional_ppi_for_cci(ppi_data=shuffled_ppi_data, verbose=False)\n",
    "    interaction_space = c2c.core.InteractionSpace(rnaseq_data=rnaseq_data[included_cells],\n",
    "                                                  ppi_data=bi_ppi_data,\n",
    "                                                  gene_cutoffs=cutoff_setup,\n",
    "                                                  communication_score=analysis_setup['communication_score'],\n",
    "                                                  cci_score=analysis_setup['cci_score'],\n",
    "                                                  cci_type=analysis_setup['cci_type'],\n",
    "                                                  verbose=False)\n",
    "    \n",
    "    interaction_space.compute_pairwise_cci_scores(verbose=False)\n",
    "    \n",
    "    corr_dist['permutation'][shuffle_col].append(get_correlation(physical_distance.loc[included_cells, included_cells],\n",
    "                                                                 interaction_space.interaction_elements['cci_matrix'].loc[included_cells, included_cells],\n",
    "                                                                 corr_type = 'spearman'\n",
    "                                                                 )\n",
    "                                                 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Permutate Receptors**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████| 9999/9999 [16:49<00:00,  9.90it/s]\n"
     ]
    }
   ],
   "source": [
    "shuffle_col = 'B'\n",
    "corr_dist['permutation'][shuffle_col] = []\n",
    "\n",
    "for i in tqdm(range(permu_number)):\n",
    "    shuffled_ppi_data = c2c.preprocessing.shuffle_cols_in_df(ppi_data, shuffle_col, random_state=i)\n",
    "    bi_ppi_data = c2c.preprocessing.bidirectional_ppi_for_cci(ppi_data=shuffled_ppi_data, verbose=False)\n",
    "    interaction_space = c2c.core.InteractionSpace(rnaseq_data=rnaseq_data[included_cells],\n",
    "                                                  ppi_data=bi_ppi_data,\n",
    "                                                  gene_cutoffs=cutoff_setup,\n",
    "                                                  communication_score=analysis_setup['communication_score'],\n",
    "                                                  cci_score=analysis_setup['cci_score'],\n",
    "                                                  cci_type=analysis_setup['cci_type'],\n",
    "                                                  verbose=False)\n",
    "    \n",
    "    interaction_space.compute_pairwise_cci_scores(verbose=False)\n",
    "    \n",
    "    corr_dist['permutation'][shuffle_col].append(get_correlation(physical_distance.loc[included_cells, included_cells],\n",
    "                                                                 interaction_space.interaction_elements['cci_matrix'].loc[included_cells, included_cells],\n",
    "                                                                 corr_type = 'spearman'\n",
    "                                                                 )\n",
    "                                                 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Switch labels of proteins (ligands or receptors, independently)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Switch Ligand Labels**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████| 9999/9999 [16:47<00:00,  9.92it/s]\n"
     ]
    }
   ],
   "source": [
    "shuffle_col = 'A'\n",
    "corr_dist['label_switching'][shuffle_col] = []\n",
    "\n",
    "for i in tqdm(range(permu_number)):\n",
    "    shuffled_ppi_data = c2c.stats.random_switching_ppi_labels(ppi_data, permuted_column='first', random_state=i)\n",
    "    bi_ppi_data = c2c.preprocessing.bidirectional_ppi_for_cci(ppi_data=shuffled_ppi_data, verbose=False)\n",
    "    interaction_space = c2c.core.InteractionSpace(rnaseq_data=rnaseq_data[included_cells],\n",
    "                                                  ppi_data=bi_ppi_data,\n",
    "                                                  gene_cutoffs=cutoff_setup,\n",
    "                                                  communication_score=analysis_setup['communication_score'],\n",
    "                                                  cci_score=analysis_setup['cci_score'],\n",
    "                                                  cci_type=analysis_setup['cci_type'],\n",
    "                                                  verbose=False)\n",
    "    \n",
    "    interaction_space.compute_pairwise_cci_scores(verbose=False)\n",
    "    \n",
    "    corr_dist['label_switching'][shuffle_col].append(get_correlation(physical_distance.loc[included_cells, included_cells],\n",
    "                                                                     interaction_space.interaction_elements['cci_matrix'].loc[included_cells, included_cells],\n",
    "                                                                     corr_type = 'spearman'\n",
    "                                                                     )\n",
    "                                                     )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Switch Receptor Labels**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████| 9999/9999 [16:50<00:00,  9.90it/s]\n"
     ]
    }
   ],
   "source": [
    "shuffle_col = 'B'\n",
    "corr_dist['label_switching'][shuffle_col] = []\n",
    "\n",
    "for i in tqdm(range(permu_number)):\n",
    "    shuffled_ppi_data = c2c.stats.random_switching_ppi_labels(ppi_data, permuted_column='second', random_state=i)\n",
    "    bi_ppi_data = c2c.preprocessing.bidirectional_ppi_for_cci(ppi_data=shuffled_ppi_data, verbose=False)\n",
    "    interaction_space = c2c.core.InteractionSpace(rnaseq_data=rnaseq_data[included_cells],\n",
    "                                                  ppi_data=bi_ppi_data,\n",
    "                                                  gene_cutoffs=cutoff_setup,\n",
    "                                                  communication_score=analysis_setup['communication_score'],\n",
    "                                                  cci_score=analysis_setup['cci_score'],\n",
    "                                                  cci_type=analysis_setup['cci_type'],\n",
    "                                                  verbose=False)\n",
    "    \n",
    "    interaction_space.compute_pairwise_cci_scores(verbose=False)\n",
    "    \n",
    "    corr_dist['label_switching'][shuffle_col].append(get_correlation(physical_distance.loc[included_cells, included_cells],\n",
    "                                                                     interaction_space.interaction_elements['cci_matrix'].loc[included_cells, included_cells],\n",
    "                                                                     corr_type = 'spearman'\n",
    "                                                                     )\n",
    "                                                     )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Subsample original PPI network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████| 9999/9999 [16:46<00:00,  9.93it/s]\n"
     ]
    }
   ],
   "source": [
    "corr_dist['subsampling'] = []\n",
    "\n",
    "for i in tqdm(range(permu_number)):\n",
    "    subsampled_ppi_data = c2c.preprocessing.subsample_dataframe(df=original_ppi_data, n_samples=ppi_data.shape[0], random_state=i).reset_index(drop=True)\n",
    "    subsampled_ppi_data = subsampled_ppi_data.assign(score=1.0)\n",
    "    bi_ppi_data = c2c.preprocessing.bidirectional_ppi_for_cci(ppi_data=subsampled_ppi_data, verbose=False)\n",
    "    interaction_space = c2c.core.InteractionSpace(rnaseq_data=rnaseq_data[included_cells],\n",
    "                                                  ppi_data=bi_ppi_data,\n",
    "                                                  gene_cutoffs=cutoff_setup,\n",
    "                                                  communication_score=analysis_setup['communication_score'],\n",
    "                                                  cci_score=analysis_setup['cci_score'],\n",
    "                                                  cci_type=analysis_setup['cci_type'],\n",
    "                                                  verbose=False)\n",
    "    \n",
    "    interaction_space.compute_pairwise_cci_scores(verbose=False)\n",
    "    \n",
    "    corr_dist['subsampling'].append(get_correlation(physical_distance.loc[included_cells, included_cells],\n",
    "                                                    interaction_space.interaction_elements['cci_matrix'].loc[included_cells, included_cells],\n",
    "                                                    corr_type = 'spearman'\n",
    "                                                    )\n",
    "                                                 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compute p-values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Correlation with GA-Selected LR list**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "if analysis_setup['cci_type'] == 'undirected':\n",
    "    bi_ppi_data = c2c.preprocessing.bidirectional_ppi_for_cci(ppi_data=ppi_data, verbose=False)\n",
    "    ref_ppi = ppi_data\n",
    "else:\n",
    "    bi_ppi_data = ppi_data.copy()\n",
    "    ref_ppi = None\n",
    "\n",
    "interaction_space = c2c.core.InteractionSpace(rnaseq_data=rnaseq_data[included_cells],\n",
    "                                              ppi_data=bi_ppi_data,\n",
    "                                              gene_cutoffs=cutoff_setup,\n",
    "                                              communication_score=analysis_setup['communication_score'],\n",
    "                                              cci_score=analysis_setup['cci_score'],\n",
    "                                              cci_type=analysis_setup['cci_type'],\n",
    "                                              verbose=False)\n",
    "\n",
    "interaction_space.compute_pairwise_cci_scores(verbose=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SpearmanrResult(correlation=-0.6333657309057459, pvalue=2.6294765000591562e-27)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Correlation\n",
    "corr_value = get_correlation(physical_distance.loc[included_cells, included_cells],\n",
    "                             interaction_space.interaction_elements['cci_matrix'].loc[included_cells, included_cells],\n",
    "                             corr_type = 'spearman'\n",
    "                             )\n",
    "\n",
    "corr_value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add analysis value to the random distributions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "corr_dist['permutation']['A'].append(corr_value)\n",
    "corr_dist['permutation']['B'].append(corr_value)\n",
    "corr_dist['label_switching']['A'].append(corr_value)\n",
    "corr_dist['label_switching']['B'].append(corr_value)\n",
    "corr_dist['subsampling'].append(corr_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Permutation of columns (ligands/receptor)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/earmingol/anaconda3/envs/cell2cell/lib/python3.7/site-packages/seaborn/distributions.py:2619: FutureWarning: `distplot` is a deprecated function and will be removed in a future version. Please adapt your code to use either `displot` (a figure-level function with similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P-value is: 0.0002\n",
      "P-value is: 0.0002\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/earmingol/anaconda3/envs/cell2cell/lib/python3.7/site-packages/seaborn/distributions.py:2619: FutureWarning: `distplot` is a deprecated function and will be removed in a future version. Please adapt your code to use either `displot` (a figure-level function with similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig_l, pval_l = c2c.stats.pvalue_from_dist(corr_value[0],\n",
    "                                           [corr[0] for corr in corr_dist['permutation']['A']],\n",
    "                                           label='Ligand Permutation',\n",
    "                                           comparison='different'\n",
    "                                          )\n",
    "\n",
    "fig_r, pval_r = c2c.stats.pvalue_from_dist(corr_value[0],\n",
    "                                           [corr[0] for corr in corr_dist['permutation']['B']],\n",
    "                                           label='Receptor Permutation',\n",
    "                                           comparison='different'\n",
    "                                          )\n",
    "    \n",
    "plt.xlabel('Spearman score', fontsize=18)\n",
    "plt.ylabel('Counts', fontsize=18)\n",
    "\n",
    "plt.savefig(output_folder + '/Pval-Permutation-LR.svg',\n",
    "                dpi=300,\n",
    "                bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Shuffling Protein names**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P-value is: 0.0002\n",
      "P-value is: 0.0002\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/earmingol/anaconda3/envs/cell2cell/lib/python3.7/site-packages/seaborn/distributions.py:2619: FutureWarning: `distplot` is a deprecated function and will be removed in a future version. Please adapt your code to use either `displot` (a figure-level function with similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "  warnings.warn(msg, FutureWarning)\n",
      "/home/earmingol/anaconda3/envs/cell2cell/lib/python3.7/site-packages/seaborn/distributions.py:2619: FutureWarning: `distplot` is a deprecated function and will be removed in a future version. Please adapt your code to use either `displot` (a figure-level function with similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig_l, pval_l = c2c.stats.pvalue_from_dist(corr_value[0],\n",
    "                                           [corr[0] for corr in corr_dist['label_switching']['A']],\n",
    "                                           label='Ligand Label Shuffling',\n",
    "                                           comparison='different'\n",
    "                                          )\n",
    "\n",
    "fig_r, pval_r = c2c.stats.pvalue_from_dist(corr_value[0],\n",
    "                                           [corr[0] for corr in corr_dist['label_switching']['B']],\n",
    "                                           label='Receptor Label Shuffling',\n",
    "                                           comparison='different'\n",
    "                                          )\n",
    "    \n",
    "plt.xlabel('Spearman score', fontsize=18)\n",
    "plt.ylabel('Counts', fontsize=18)\n",
    "\n",
    "plt.savefig(output_folder + '/Pval-Label-Shuffling-LR.svg',\n",
    "                dpi=300,\n",
    "                bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**PPI Network Subsampling**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P-value is: 0.0002\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/earmingol/anaconda3/envs/cell2cell/lib/python3.7/site-packages/seaborn/distributions.py:2619: FutureWarning: `distplot` is a deprecated function and will be removed in a future version. Please adapt your code to use either `displot` (a figure-level function with similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig_, pval = c2c.stats.pvalue_from_dist(corr_value[0],\n",
    "                                        [corr[0] for corr in corr_dist['subsampling']],\n",
    "                                        label='PPI Network Subsampling',\n",
    "                                        comparison='different'\n",
    "                                       )\n",
    "    \n",
    "plt.xlabel('Spearman score', fontsize=18)\n",
    "plt.ylabel('Counts', fontsize=18)\n",
    "\n",
    "plt.savefig(output_folder + '/Pval-PPI-Subsampling.svg',\n",
    "                dpi=300,\n",
    "                bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Export results into JSON File"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(output_folder + '/Permutation-Analysis.json', 'w') as outfile:\n",
    "    json.dump(corr_dist, outfile)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}