{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b1a18e6a",
   "metadata": {},
   "source": [
    "## S3B. Decomposition Consistency between Score Types\n",
    "\n",
    "We can also check how consistent each score type is after running the full Tensor-cell2cell pipeline. The [CorrIndex](https://doi.org/10.1016/j.sigpro.2022.108457) provides a dissimilarity metric that can compare decompositions of the same rank. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "7ff9779d",
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "import itertools\n",
    "import os\n",
    "\n",
    "import matplotlib\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import torch\n",
    "\n",
    "import liana as li\n",
    "import cell2cell as c2c\n",
    "from cell2cell.tensor.metrics import correlation_index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "371effc8",
   "metadata": {},
   "outputs": [],
   "source": [
    "if torch.cuda.is_available():\n",
    "    import tensorly as tl\n",
    "    tl.set_backend('pytorch')\n",
    "    device = 'cuda:0'\n",
    "else:\n",
    "    device = 'cpu'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "3a63b36d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "../../data/tc2c-outputs/ already exists.\n"
     ]
    }
   ],
   "source": [
    "data_folder = '../../data/liana-outputs/'\n",
    "output_folder = '../../data/tc2c-outputs/'\n",
    "c2c.io.directories.create_directory(output_folder)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7bf0048d",
   "metadata": {},
   "source": [
    "First, let's load the LIANA scores for each sample and score type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "df96a813",
   "metadata": {},
   "outputs": [],
   "source": [
    "liana_res = pd.read_csv(data_folder + 'LIANA_by_sample.csv')\n",
    "sorted_samples = sorted(liana_res['sample_new'].unique())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec974229",
   "metadata": {},
   "source": [
    "Next, we can generate and decompose the tensor as in [Tutorial 03](./03-Generate-Tensor.ipynb) and [Tutorial 04](./04-Perform-Tensor-Factorization) respectively, but for each magnitude rank score separately. We will use the rank identified by the consensus magnitude score in Tutorial 04. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0eb5e6f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "tf_optimization_dict = {'regular': {'runs': 1, \n",
    "                                         'tol': 10e-7, \n",
    "                                           'n_iter_max': 100}, \n",
    "                            'robust': {'runs': 100, \n",
    "                                         'tol': 10e-8, \n",
    "                                           'n_iter_max': 500}}\n",
    "\n",
    "def run_tensor_pipeline(liana_res, score_type, rank, \n",
    "                       tf_optimization = 'robust'):\n",
    "    # build tensor\n",
    "    tensor = li.multi.to_tensor_c2c(liana_res=liana_res, # LIANA's dataframe containing results\n",
    "                                    sample_key='sample_new', # Column name of the samples\n",
    "                                    source_key='source', # Column name of the sender cells\n",
    "                                    target_key='target', # Column name of the receiver cells\n",
    "                                    ligand_key='ligand_complex', # Column name of the ligands\n",
    "                                    receptor_key='receptor_complex', # Column name of the receptors\n",
    "                                    score_key=score_type, # Column name of the communication scores to use\n",
    "                                    non_negative = True, # set negative values to 0\n",
    "                                    inverse_fun=lambda x: x, # Transformation function -- don't invert because it's not a rank score\n",
    "                                    non_expressed_fill=None, # Value to replace missing values with \n",
    "                                    how='outer', # What to include across all samples\n",
    "                                    lr_fill=np.nan, # What to fill missing LRs with \n",
    "                                    cell_fill = np.nan, # What to fill missing cell types with \n",
    "                                    outer_fraction=1/3., # Fraction of samples as threshold to include cells and LR pairs.\n",
    "                                    lr_sep='^', # How to separate ligand and receptor names to name LR pair\n",
    "                                    context_order=sorted_samples, # Order to store the contexts in the tensor\n",
    "                                    sort_elements=True # Whether sorting alphabetically element names of each tensor dim. Does not apply for context order if context_order is passed.\n",
    "                                   )\n",
    "    # get metadata\n",
    "    element_dict = defaultdict(lambda: 'Unknown')\n",
    "    context_dict = element_dict.copy()\n",
    "    context_dict.update({'HC1' : 'Control',\n",
    "                         'HC2' : 'Control',\n",
    "                         'HC3' : 'Control',\n",
    "                         'M1' : 'Moderate COVID-19',\n",
    "                         'M2' : 'Moderate COVID-19',\n",
    "                         'M3' : 'Moderate COVID-19',\n",
    "                         'S1' : 'Severe COVID-19',\n",
    "                         'S2' : 'Severe COVID-19',\n",
    "                         'S3' : 'Severe COVID-19',\n",
    "                         'S4' : 'Severe COVID-19',\n",
    "                         'S5' : 'Severe COVID-19',\n",
    "                         'S6' : 'Severe COVID-19',\n",
    "                        })\n",
    "    dimensions_dict = [context_dict, None, None, None]\n",
    "    meta_tensor = c2c.tensor.generate_tensor_metadata(interaction_tensor=tensor,\n",
    "                                              metadata_dicts=[context_dict, None, None, None],\n",
    "                                              fill_with_order_elements=True\n",
    "                                             )\n",
    "    \n",
    "    # decompose tensor\n",
    "    tensor.to_device(device)\n",
    "    tensor.compute_tensor_factorization(rank=rank,\n",
    "                                        init='random', # Initialization method of the tensor factorization\n",
    "                                        svd='numpy_svd', # Type of SVD to use if the initialization is 'svd'\n",
    "                                        random_state=0, # Random seed for reproducibility\n",
    "                                        normalize_loadings=True,\n",
    "                                        runs=tf_optimization_dict[tf_optimization]['runs'],\n",
    "                                        tol=tf_optimization_dict[tf_optimization]['tol'],\n",
    "                                        n_iter_max=tf_optimization_dict[tf_optimization]['n_iter_max']\n",
    "                                       )\n",
    "    return tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e820c7e2",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/hratch/miniconda3/envs/ccc_protocols/lib/python3.10/site-packages/tensorly/backend/pytorch_backend.py:39: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n"
     ]
    }
   ],
   "source": [
    "tensor_magnitude = c2c.io.read_data.load_tensor(os.path.join(output_folder, 'BALF-Tensor_decomposed.pkl'))\n",
    "magnitude_scores = ['lr_means', 'expr_prod', 'lrscore', 'lr_probs']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "eb26162a",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████| 12/12 [00:18<00:00,  1.54s/it]\n",
      "/home/hratch/miniconda3/envs/ccc_protocols/lib/python3.10/site-packages/tensorly/backend/pytorch_backend.py:39: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "100%|█████████████████████████████████████████| 100/100 [05:50<00:00,  3.50s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best model has a normalized error of: 0.207\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████| 12/12 [00:18<00:00,  1.54s/it]\n",
      "/home/hratch/miniconda3/envs/ccc_protocols/lib/python3.10/site-packages/tensorly/backend/pytorch_backend.py:39: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "100%|█████████████████████████████████████████| 100/100 [05:46<00:00,  3.46s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best model has a normalized error of: 0.340\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████| 12/12 [00:18<00:00,  1.54s/it]\n",
      "/home/hratch/miniconda3/envs/ccc_protocols/lib/python3.10/site-packages/tensorly/backend/pytorch_backend.py:39: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "100%|█████████████████████████████████████████| 100/100 [05:31<00:00,  3.31s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best model has a normalized error of: 0.079\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████| 12/12 [00:18<00:00,  1.54s/it]\n",
      "/home/hratch/miniconda3/envs/ccc_protocols/lib/python3.10/site-packages/tensorly/backend/pytorch_backend.py:39: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "100%|█████████████████████████████████████████| 100/100 [05:54<00:00,  3.55s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best model has a normalized error of: 0.502\n",
      "../../data/tc2c-outputs//BALF-Tensor_individualscores.pkl  was correctly saved.\n"
     ]
    }
   ],
   "source": [
    "tensors_individual = {}\n",
    "# calculate on each magnitude score type separately\n",
    "for score_type in magnitude_scores:\n",
    "    ti = run_tensor_pipeline(liana_res = liana_res,\n",
    "                             score_type = score_type,\n",
    "                             rank = tensor_magnitude.rank, \n",
    "                             tf_optimization = 'robust')\n",
    "    ti.to_device('cpu') # ensures can be pickled properly\n",
    "    tensors_individual[score_type] = ti\n",
    "c2c.io.export_variable_with_pickle(tensors_individual, output_folder + '/BALF-Tensor_individualscores.pkl')\n",
    "\n",
    "tensors_individual = c2c.io.read_data.load_variable_with_pickle(output_folder + '/BALF-Tensor_individualscores.pkl')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56ce9375",
   "metadata": {},
   "source": [
    "Next, we can calculate the similarity between each score type's deomposition output based on the CorrIndex metric. For more information on the CorrIndex, as well as similar analyses on decomposition consistency, see Figure 3A of this [paper](https://doi.org/10.1038/s41467-022-31369-2):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "757afb83",
   "metadata": {},
   "outputs": [],
   "source": [
    "corrindex_res = pd.DataFrame(columns = ['score_type_1', 'score_type_2', 'Similarity'])\n",
    "\n",
    "# calculate corrindex pairwise between score types\n",
    "for idx, score_type_comparison in enumerate(itertools.permutations(tensors_individual, 2)):\n",
    "    tensor_1 = tensors_individual[score_type_comparison[0]]\n",
    "    tensor_2 = tensors_individual[score_type_comparison[1]]\n",
    "    corrindex = correlation_index(tensor_1.factors, tensor_2.factors)\n",
    "    similarity = 1 - corrindex\n",
    "    \n",
    "    corrindex_res.loc[idx, :] = list(score_type_comparison) + [similarity]\n",
    "\n",
    "# formatting\n",
    "corrindex_res = corrindex_res.pivot(index='score_type_1', columns='score_type_2', values = 'Similarity')\n",
    "corrindex_res.columns = corrindex_res.columns.tolist()\n",
    "corrindex_res.index = corrindex_res.index.tolist()\n",
    "np.fill_diagonal(corrindex_res.values, 1)\n",
    "for col_name in corrindex_res.columns:\n",
    "    corrindex_res[col_name] = corrindex_res[col_name].astype(float)\n",
    "    \n",
    "method_name_map = {'expr_prod': 'Connectome/NATMI', \n",
    "                  'lr_means': 'CellPhoneDB', \n",
    "                  'lr_probs': 'CellChat', \n",
    "                  'lrscore': 'SingleCellSignalR'}\n",
    "corrindex_res.columns = corrindex_res.columns.map(method_name_map).tolist()\n",
    "corrindex_res.index = corrindex_res.index.map(method_name_map).tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "12af791e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Interaction space detected as a distance matrix\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x500 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cm = c2c.plotting.clustermap_cci(corrindex_res,\n",
    "                                 method='ward',\n",
    "                                 optimal_leaf=True,\n",
    "                                 metadata=None,\n",
    "                                 title='',\n",
    "                                 cbar_title='Similarity', \n",
    "                                 cmap='Blues_r',\n",
    "                                 vmax=1.,\n",
    "#                                  vmin=0.,\n",
    "                                 annot=True, \n",
    "                                 dendrogram_ratio=0.15,\n",
    "                                figsize=(4,5))\n",
    "\n",
    "font = matplotlib.font_manager.FontProperties(weight='bold', size=7)\n",
    "for ax in [cm.ax_heatmap, cm.ax_cbar]:\n",
    "    for tick in ax.get_xticklabels():\n",
    "        tick.set_fontproperties(font)\n",
    "    for tick in ax.get_yticklabels():\n",
    "        tick.set_fontproperties(font)\n",
    "\n",
    "    text = ax.yaxis.label\n",
    "    text.set_font_properties(font)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c71f40dc",
   "metadata": {},
   "source": [
    "Given the high overall similarity between score types, we see that Tensor-cell2cell's decomposition tends to capture consistent patterns across samples, smoothing over some of the inconsistencies in communication scores that we saw at the individual sample level in [Tutorial 02](./02-Infer-Communication-Scores.ipynb) "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:ccc_protocols]",
   "language": "python",
   "name": "conda-env-ccc_protocols-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.10.0"
  },
  "vscode": {
   "interpreter": {
    "hash": "a89d9df9e41c144bbb86b791904f32fb0efeb7b488a88d676a8bce57017c9696"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}