BLAST_GenePrediction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### These jupyter can reproduced the results of figure2 in our papers.\n",
    "### you can use these functions we defined to evaluate the performance of each method with 10-X cross-validation.\n",
    "### If you want to use each method to analyse youe own data, please see the Tutorial.ipynb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Please note: We used raw count as input for predictions in this ipynb !!!\n",
    "\n",
    "### In our manuscripts, we tested four schemes of input expression matrices: \n",
    "### (1) raw expression matrix of spatial data and raw expression matrix of scRNA-seq data (R-R); \n",
    "### (2) normalized expression matrix of spatial data and raw expression matrix of scRNA-seq data (N-R); \n",
    "### (3) raw expression matrix of spatial data and normalized expression matrix of scRNA-seq data (R-N); \n",
    "### (4) normalized expression matrix of spatial data and normalized expression matrix of scRNA-seq data (N-N).\n",
    "\n",
    "### For N-N and N-R input, we calculate the accuracy by comapring the prediction result with normalized matrix of spatial data.\n",
    "### For R-R and R-N input, we calculate the accuracy by comapring the prediction result with raw expression matrix of spatial data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import sys\n",
    "import pickle\n",
    "import os\n",
    "import time as tm\n",
    "from functools import partial\n",
    "import scipy.stats as st\n",
    "from scipy.stats import wasserstein_distance\n",
    "import scipy.stats\n",
    "import copy\n",
    "from sklearn.model_selection import KFold\n",
    "import pandas as pd\n",
    "import multiprocessing\n",
    "import matplotlib as mpl \n",
    "import matplotlib.pyplot as plt\n",
    "import scanpy as sc\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "from scipy.spatial import distance_matrix\n",
    "from sklearn.metrics import matthews_corrcoef\n",
    "from scipy import stats\n",
    "import seaborn as sns\n",
    "\n",
    "from scipy.spatial.distance import cdist\n",
    "import h5py\n",
    "from scipy.stats import spearmanr\n",
    "\n",
    "import time\n",
    "import sys\n",
    "import tangram as tg\n",
    "from os.path import join\n",
    "from IPython.display import display\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def SpaGE_impute(K):\n",
    "    print ('We run SpaGE for this data\\n')\n",
    "    sys.path.append(\"Extenrnal/SpaGE-master/\")\n",
    "    from SpaGE.main import SpaGE\n",
    "    global RNA_data, Spatial_data, train_gene, predict_gene\n",
    "    RNA_data = RNA_data.loc[(RNA_data.sum(axis=1) != 0)]\n",
    "    RNA_data = RNA_data.loc[(RNA_data.var(axis=1) != 0)]\n",
    "    train = np.array(train_gene[K])\n",
    "    predict = np.array(predict_gene[K])\n",
    "    pv = len(train)/2\n",
    "    Spatial = Spatial_data[train]\n",
    "    Img_Genes = SpaGE(Spatial, RNA_data.T, n_pv = int(pv), genes_to_predict = predict)\n",
    "    result = Img_Genes[predict]\n",
    "    return result\n",
    "\n",
    "def gimVI_impute(K):\n",
    "    print ('We run gimVI for this data\\n')\n",
    "    import scvi\n",
    "    import scanpy as sc\n",
    "    from scvi.model import GIMVI\n",
    "    import torch\n",
    "    from torch.nn.functional import softmax, cosine_similarity, sigmoid\n",
    "    global RNA_data_adata, Spatial_data_adata, train_gene, predict_gene\n",
    "    test_list = np.array(predict_gene[K])\n",
    "    train_list = np.array(train_gene[K])\n",
    "    Genes  = list(Spatial_data_adata.var_names)\n",
    "    rand_gene_idx = [Genes.index(x) for x in test_list]\n",
    "    n_genes = len(Genes)\n",
    "    rand_train_gene_idx = sorted(set(range(n_genes)) - set(rand_gene_idx))\n",
    "    rand_train_genes = np.array(Genes)[rand_train_gene_idx]\n",
    "    rand_genes = np.array(Genes)[rand_gene_idx]\n",
    "    spatial_data_partial = Spatial_data_adata[:, rand_train_genes]\n",
    "    sc.pp.filter_cells(spatial_data_partial, min_counts= 0)\n",
    "    seq_data = copy.deepcopy(RNA_data_adata)\n",
    "    seq_data = seq_data[:, Genes]\n",
    "    sc.pp.filter_cells(seq_data, min_counts = 0)\n",
    "    scvi.data.setup_anndata(spatial_data_partial)\n",
    "    scvi.data.setup_anndata(seq_data)\n",
    "    model = GIMVI(seq_data, spatial_data_partial)\n",
    "    model.train(200)\n",
    "    _, imputation = model.get_imputed_values(normalized = False)\n",
    "    imputed = imputation[:, rand_gene_idx]\n",
    "    result = pd.DataFrame(imputed, columns = rand_genes)\n",
    "    print (test_list ==  rand_genes)\n",
    "    print (train_list ==  rand_train_genes)\n",
    "    return result\n",
    "                       \n",
    "def novoSpaRc_impute(K):\n",
    "    print ('We run novoSpaRc for this data\\n')\n",
    "    import novosparc as nc\n",
    "    global RNA_data, Spatial_data, locations, train_gene, predict_gene\n",
    "    test_list = np.array(predict_gene[K])\n",
    "    train_list = np.array(train_gene[K])\n",
    "    gene_names = np.array(RNA_data.index.values)\n",
    "    dge = RNA_data.values\n",
    "    dge = dge.T\n",
    "    num_cells = dge.shape[0]\n",
    "    print ('number of cells and genes in the matrix:', dge.shape)\n",
    "\n",
    "    hvg = np.argsort(np.divide(np.var(dge, axis = 0),np.mean(dge, axis = 0) + 0.0001))\n",
    "    dge_hvg = dge[:,hvg[-2000:]]\n",
    "\n",
    "    num_locations = locations.shape[0]\n",
    "\n",
    "    p_location, p_expression = nc.rc.create_space_distributions(num_locations, num_cells)\n",
    "    cost_expression, cost_locations = nc.rc.setup_for_OT_reconstruction(dge_hvg,locations,num_neighbors_source = 5,num_neighbors_target = 5)\n",
    "\n",
    "    insitu_matrix = np.array(Spatial_data[train_list])\n",
    "    insitu_genes = np.array(Spatial_data[train_list].columns)\n",
    "    test_genes = np.array(test_list)\n",
    "    test_matrix = np.array(Spatial_data[test_list])\n",
    "\n",
    "    markers_in_sc = np.array([], dtype='int')\n",
    "    for marker in insitu_genes:\n",
    "        marker_index = np.where(gene_names == marker)[0]\n",
    "        if len(marker_index) > 0:\n",
    "            markers_in_sc = np.append(markers_in_sc, marker_index[0])\n",
    "    cost_marker_genes = cdist(dge[:, markers_in_sc]/np.amax(dge[:, markers_in_sc]),insitu_matrix/np.amax(insitu_matrix))\n",
    "    alpha_linear = 0.5\n",
    "    gw = nc.rc._GWadjusted.gromov_wasserstein_adjusted_norm(cost_marker_genes, cost_expression, cost_locations,alpha_linear, p_expression, p_location,'square_loss', epsilon=5e-3, verbose=True)\n",
    "    sdge = np.dot(dge.T, gw)\n",
    "    imputed = pd.DataFrame(sdge,index = RNA_data.index)\n",
    "    result = imputed.loc[test_genes]\n",
    "    result = result.T\n",
    "    return result\n",
    "                       \n",
    "def SpaOTsc_impute(K):\n",
    "    print ('We run SpaOTsc for this data\\n')\n",
    "    from spaotsc import SpaOTsc\n",
    "    global RNA_data, Spatial_data, locations, train_gene, predict_gene\n",
    "    test_list = np.array(predict_gene[K])\n",
    "    train_list = np.array(train_gene[K])\n",
    "    df_sc = RNA_data.T\n",
    "    df_IS = Spatial_data\n",
    "    pts = locations\n",
    "    is_dmat = distance_matrix(pts, pts)\n",
    "    df_is = df_IS.loc[:,train_list]\n",
    "\n",
    "    gene_is = df_is.columns.tolist()\n",
    "    gene_sc = df_sc.columns.tolist()\n",
    "    gene_overloap = list(set(gene_is).intersection(gene_sc))\n",
    "    a = df_is[gene_overloap]\n",
    "    b = df_sc[gene_overloap]\n",
    "\n",
    "    rho, pval = stats.spearmanr(a, b,axis=1)\n",
    "    rho[np.isnan(rho)]=0\n",
    "    mcc=rho[-(len(df_sc)):,0:len(df_is)]\n",
    "    C = np.exp(1 - mcc)\n",
    "    issc = SpaOTsc.spatial_sc(sc_data = df_sc, is_data = df_is, is_dmat = is_dmat)\n",
    "    issc.transport_plan(C**2, alpha = 0, rho = 1.0, epsilon = 0.1, cor_matrix = mcc, scaling = False)\n",
    "    gamma = issc.gamma_mapping\n",
    "    for j in range(gamma.shape[1]):\n",
    "        gamma[:,j] = gamma[:,j]/np.sum(gamma[:,j])\n",
    "    X_pred = np.matmul(gamma.T, np.array(issc.sc_data.values))\n",
    "    result = pd.DataFrame(data = X_pred, columns = issc.sc_data.columns.values)\n",
    "    test_genes = test_list\n",
    "    result = result.loc[:, test_genes]\n",
    "    return result\n",
    "\n",
    "def stPlus_impute(K):\n",
    "    global RNA_data, Spatial_data, outdir, train_gene, predict_gene\n",
    "    test_list = np.array(predict_gene[K])\n",
    "    train_list = np.array(train_gene[K])\n",
    "    save_path_prefix = join(outdir, 'process_file/stPlus-demo')\n",
    "    if not os.path.exists(join(outdir, \"process_file\")):\n",
    "        os.mkdir(join(outdir, \"process_file\"))\n",
    "    stPlus_res = stPlus(Spatial_data[train_list], RNA_data.T, test_list, save_path_prefix)\n",
    "    return stPlus_res\n",
    "                       \n",
    "def Tangram_impute(K, annotate = None, modes = 'clusters', density = 'rna_count_based'):\n",
    "    import torch\n",
    "    from torch.nn.functional import softmax, cosine_similarity, sigmoid\n",
    "    import tangram as tg\n",
    "    print ('We run Tangram for this \\n' + DataDir)\n",
    "    global RNA_data_adata, Spatial_data_adata, locations, train_gene, predict_gene\n",
    "    test_list = predict_gene[K]\n",
    "    test_list = [x.lower() for x in test_list]\n",
    "    train_list = train_gene[K]\n",
    "    spatial_data_partial = Spatial_data_adata[:, train_list]\n",
    "    train_list = np.array(train_list)\n",
    "    if annotate == None:\n",
    "        RNA_data_adata_label = RNA_data_adata\n",
    "        sc.pp.normalize_total(RNA_data_adata_label)\n",
    "        sc.pp.log1p(RNA_data_adata_label)\n",
    "        sc.pp.highly_variable_genes(RNA_data_adata_label)\n",
    "        RNA_data_adata_label = RNA_data_adata_label[:, RNA_data_adata_label.var.highly_variable]\n",
    "        sc.pp.scale(RNA_data_adata_label, max_value=10)\n",
    "        sc.tl.pca(RNA_data_adata_label)\n",
    "        sc.pp.neighbors(RNA_data_adata_label)\n",
    "        sc.tl.leiden(RNA_data_adata_label, resolution = 0.5)\n",
    "        RNA_data_adata.obs['leiden']  = RNA_data_adata_label.obs.leiden\n",
    "    else:\n",
    "        global CellTypeAnnotate\n",
    "        RNA_data_adata.obs['leiden']  = CellTypeAnnotate\n",
    "    tg.pp_adatas(RNA_data_adata, spatial_data_partial, genes=train_list)\n",
    "    device = torch.device('cuda:0')\n",
    "    if modes == 'clusters':\n",
    "        ad_map = tg.map_cells_to_space(RNA_data_adata, spatial_data_partial, device = device, mode = modes, cluster_label = 'leiden', density_prior = density)\n",
    "        ad_ge = tg.project_genes(ad_map, RNA_data_adata, cluster_label = 'leiden')\n",
    "    else:\n",
    "        ad_map = tg.map_cells_to_space(RNA_data_adata, spatial_data_partial, device = device)\n",
    "        ad_ge = tg.project_genes(ad_map, RNA_data_adata)\n",
    "    test_list = list(set(ad_ge.var_names) & set(test_list))\n",
    "    test_list = np.array(test_list)\n",
    "    pre_gene = pd.DataFrame(ad_ge[:,test_list].X, index=ad_ge[:,test_list].obs_names, columns=ad_ge[:,test_list].var_names)\n",
    "    return pre_gene\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Input"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# First, you can download Example datasets from our websites "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "@author: wen zhang\n",
    "This function integrates two single-cell datasets, spatial and scRNA-seq, \n",
    "and predictes the expression of the spatially unmeasured genes from the scRNA-seq data.\n",
    "\n",
    "Parameters\n",
    "-------\n",
    "RNA_file : str\n",
    "    scRNA-seq data count file with Tab-delimited (cells X genes).\n",
    "Spatial_file : str\n",
    "    spatial count data file with Tab-delimited, please note that the file has no index.\n",
    "location_file : str\n",
    "    spatial spot coordinate file name with Tab-delimited, please note that the file has no index.\n",
    "device : str\n",
    "    Option,  ['CPU','GPU'], defaults to 'CPU'\n",
    "train_gene : list\n",
    "    genes for integrations, you can support more than one train list.\n",
    "predict_gene : list\n",
    "    genes for prediction, you can support more than one test list.\n",
    "outdir : str\n",
    "    result file stored direction    \n",
    "\"\"\"\n",
    "\n",
    "DataDir = 'DataUpload/Dataset4/'\n",
    "outdir = 'SpatialBenchmarking/FigureData/Figure2/Dataset4/'\n",
    "RNA_file = DataDir + 'scRNA_count.txt'\n",
    "Spatial_file = DataDir + 'Insitu_count.txt'\n",
    "location_file = DataDir + 'Locations.txt'\n",
    "\n",
    "RNA_data = pd.read_table(RNA_file, header=0, index_col = 0)\n",
    "Spatial_data = pd.read_table(Spatial_file, sep = '\\t',header = 0)\n",
    "RNA_data_adata = sc.read(RNA_file, sep = '\\t', first_column_names = True).T\n",
    "Spatial_data_adata = sc.read(Spatial_file, sep = '\\t')\n",
    "locations = np.loadtxt(location_file, skiprows=1)\n",
    "\n",
    "train_gene = np.load(DataDir + 'train_list.npy', allow_pickle = True).tolist()\n",
    "predict_gene = np.load(DataDir + 'test_list.npy', allow_pickle = True).tolist()\n",
    "\n",
    "device = 'GPU'\n",
    "if not os.path.exists(outdir):\n",
    "    os.mkdir(outdir)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Predicting undetected transcripts by each method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We run SpaGE for this data\n",
      "We run SpaGE for this data\n",
      "We run SpaGE for this data\n",
      "We run SpaGE for this data\n",
      "We run SpaGE for this data\n",
      "We run SpaGE for this data\n",
      "We run SpaGE for this data\n",
      "We run SpaGE for this data\n",
      "We run SpaGE for this data\n",
      "We run SpaGE for this data\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "KFOLD = list(range(len(train_gene)))\n",
    "with multiprocessing.Pool(10) as pool:\n",
    "    result = pd.concat(pool.map(SpaGE_impute, KFOLD), axis = 1)\n",
    "result.to_csv(outdir + \"/SpaGE_impute.csv\", header = 1, index = 1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We run SpaOTsc for this data\n",
      "We run SpaOTsc for this data\n",
      "We run SpaOTsc for this data\n",
      "We run SpaOTsc for this data\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "We run SpaOTsc for this data\n",
      "We run SpaOTsc for this data\n",
      "We run SpaOTsc for this data\n",
      "We run SpaOTsc for this data\n",
      "We run SpaOTsc for this data\n",
      "We run SpaOTsc for this data\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "KFOLD = list(range(len(train_gene)))\n",
    "with multiprocessing.Pool(10) as pool:\n",
    "    result = pd.concat(pool.map(SpaOTsc_impute, KFOLD), axis = 1)\n",
    "result.to_csv(outdir + \"/SpaOTsc_impute.csv\", header = 1, index = 1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We run novoSpaRc for this data\n",
      "We run novoSpaRc for this data\n",
      "We run novoSpaRc for this data\n",
      "We run novoSpaRc for this data\n",
      "We run novoSpaRc for this data\n",
      "We run novoSpaRc for this data\n",
      "We run novoSpaRc for this data\n",
      "We run novoSpaRc for this data\n",
      "We run novoSpaRc for this data\n",
      "We run novoSpaRc for this data\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "number of cells and genes in the matrix: (14249, 34041)\n",
      "number of cells and genes in the matrix:number of cells and genes in the matrix:number of cells and genes in the matrix:number of cells and genes in the matrix:number of cells and genes in the matrix:number of cells and genes in the matrix:number of cells and genes in the matrix:number of cells and genes in the matrix:number of cells and genes in the matrix:       (14249, 34041)(14249, 34041) (14249, 34041) (14249, 34041)(14249, 34041)(14249, 34041)(14249, 34041)\n",
      "\n",
      "(14249, 34041)(14249, 34041)\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "Setting up for reconstruction ... Setting up for reconstruction ... Setting up for reconstruction ... Setting up for reconstruction ... Setting up for reconstruction ... Setting up for reconstruction ... Setting up for reconstruction ... Setting up for reconstruction ... Setting up for reconstruction ... Setting up for reconstruction ... done (done (  612.09611.75  seconds )seconds )\n",
      "\n",
      "done ( 620.26 seconds )\n",
      "done ( 619.93 seconds )\n",
      "done ( 620.8 seconds )\n",
      "done ( 620.93 seconds )\n",
      "done ( 621.16 seconds )\n",
      "done ( 624.52 seconds )\n",
      "done ( 625.26 seconds )\n",
      "done ( 630.45 seconds )\n",
      "It.  |Err         \n",
      "-------------------\n",
      "    0|1.814710e-04|\n",
      "It.  |Err         \n",
      "-------------------\n",
      "    0|4.269427e-04|\n",
      "It.  |Err         \n",
      "-------------------\n",
      "    0|4.290345e-04|\n",
      "It.  |Err         \n",
      "-------------------\n",
      "    0|4.283379e-04|\n",
      "It.  |Err         \n",
      "-------------------\n",
      "    0|4.292212e-04|\n",
      "It.  |Err         \n",
      "-------------------\n",
      "    0|4.231047e-04|\n",
      "It.  |Err         \n",
      "-------------------\n",
      "    0|4.264612e-04|\n",
      "It.  |Err         \n",
      "-------------------\n",
      "    0|4.229334e-04|\n",
      "It.  |Err         \n",
      "-------------------\n",
      "    0|4.226364e-04|\n",
      "It.  |Err         \n",
      "-------------------\n",
      "    0|4.278680e-04|\n"
     ]
    }
   ],
   "source": [
    "KFOLD = list(range(len(train_gene)))\n",
    "with multiprocessing.Pool(10) as pool:\n",
    "    result = pd.concat(pool.map(novoSpaRc_impute, KFOLD), axis = 1)\n",
    "result.to_csv(outdir + \"/novoSpaRc_impute.csv\", header = 1, index = 1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# GPU Platform gimVI, Tangram, and stPlus"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "KFOLD = list(range(len(train_gene)))\n",
    "with multiprocessing.Pool(10) as pool:\n",
    "    result = pd.concat(pool.map(gimVI_impute, KFOLD), axis = 1)\n",
    "result.to_csv(outdir + \"/gimVI_impute.csv\", header = 1, index = 1)\n",
    "\n",
    "KFOLD = list(range(len(train_gene)))\n",
    "with multiprocessing.Pool(10) as pool:\n",
    "    result = pd.concat(pool.map(Tangram_impute, KFOLD), axis = 1)\n",
    "result.to_csv(outdir + \"/Tangram_impute.csv\", header = 1, index = 1)\n",
    "\n",
    "from stPlus import *\n",
    "KFOLD = list(range(len(train_gene)))\n",
    "result = pd.DataFrame()\n",
    "for n in KFOLD:\n",
    "    tmp = stPlus_impute(n)\n",
    "    result = pd.concat([result, tmp], axis=1)\n",
    "result.to_csv(outdir +  '/stPlus_impute.csv',header = 1, index = 1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Seurat impute file process"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_path = 'DataUpload/Dataset4/'\n",
    "output_path = 'SpatialBenchmarking/FigureData/Figure2/Dataset4/'\n",
    "os.system('Rscript SpatialBenchmarking/FigureData/Figure2/RCodes/Seurat.r ' + input_path + ' ' + output_path)\n",
    "\n",
    "PATH = 'SpatialBenchmarking/FigureData/Figure2/Dataset4/'\n",
    "DataSets = ['Dataset4']\n",
    "for Data in DataSets:\n",
    "    impute_count_file = PATH + Data + '/Seurat_impute.csv'\n",
    "    if os.path.exists(impute_count_file):\n",
    "        df = pd.read_csv(impute_count_file, header = 0, index_col = 0)\n",
    "        if df.index[0] == 0:\n",
    "            A = df\n",
    "            continue\n",
    "        print (impute_count_file)\n",
    "        Index = [(int(x)-1) for x in df.index]\n",
    "        Index = sorted(Index)\n",
    "        df.index = Index\n",
    "        B = df\n",
    "        df.to_csv(impute_count_file)\n",
    "    else:\n",
    "        print ('This outdir is none for Seurat : ' + PATH + Data)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LIGER impute file process"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_path = 'DataUpload/Dataset4/'\n",
    "output_path = 'SpatialBenchmarking/FigureData/Figure2/Dataset4/'\n",
    "os.system('Rscript SpatialBenchmarking/FigureData/Figure2/RCodes/LIGER.r ' + input_path + ' ' + output_path)\n",
    "\n",
    "PATH = 'SpatialBenchmarking/FigureData/Figure2/Dataset4/'\n",
    "DataSets = ['Dataset4']\n",
    "for Data in DataSets:\n",
    "    impute_count_file = PATH + Data + '/LIGER_impute.csv'\n",
    "    if os.path.exists(impute_count_file):\n",
    "        df = pd.read_csv(impute_count_file, header = 0, index_col = 0)\n",
    "        if df.index[0] == 0:\n",
    "            A = df\n",
    "            continue\n",
    "        print (impute_count_file)\n",
    "        Index = [(int(x.replace('V', '')) -1) for x in df.index]\n",
    "        Index = sorted(Index)\n",
    "        df.index = Index\n",
    "        B = df\n",
    "        df.to_csv(impute_count_file)\n",
    "    else:\n",
    "        print ('This outdir is none for LIGER : ' + PATH + Data)\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Calculated Metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cal_ssim(im1,im2,M):\n",
    "    assert len(im1.shape) == 2 and len(im2.shape) == 2\n",
    "    assert im1.shape == im2.shape\n",
    "    mu1 = im1.mean()\n",
    "    mu2 = im2.mean()\n",
    "    sigma1 = np.sqrt(((im1 - mu1) ** 2).mean())\n",
    "    sigma2 = np.sqrt(((im2 - mu2) ** 2).mean())\n",
    "    sigma12 = ((im1 - mu1) * (im2 - mu2)).mean()\n",
    "    k1, k2, L = 0.01, 0.03, M\n",
    "    C1 = (k1*L) ** 2\n",
    "    C2 = (k2*L) ** 2\n",
    "    C3 = C2/2\n",
    "    l12 = (2*mu1*mu2 + C1)/(mu1 ** 2 + mu2 ** 2 + C1)\n",
    "    c12 = (2*sigma1*sigma2 + C2)/(sigma1 ** 2 + sigma2 ** 2 + C2)\n",
    "    s12 = (sigma12 + C3)/(sigma1*sigma2 + C3)\n",
    "    ssim = l12 * c12 * s12\n",
    "    \n",
    "    return ssim\n",
    "\n",
    "def scale_max(df):\n",
    "    result = pd.DataFrame()\n",
    "    for label, content in df.items():\n",
    "        content = content/content.max()\n",
    "        result = pd.concat([result, content],axis=1)\n",
    "    return result\n",
    "\n",
    "def scale_z_score(df):\n",
    "    result = pd.DataFrame()\n",
    "    for label, content in df.items():\n",
    "        content = st.zscore(content)\n",
    "        content = pd.DataFrame(content,columns=[label])\n",
    "        result = pd.concat([result, content],axis=1)\n",
    "    return result\n",
    "\n",
    "\n",
    "def scale_plus(df):\n",
    "    result = pd.DataFrame()\n",
    "    for label, content in df.items():\n",
    "        content = content/content.sum()\n",
    "        result = pd.concat([result,content],axis=1)\n",
    "    return result\n",
    "\n",
    "def logNorm(df):\n",
    "    df = np.log1p(df)\n",
    "    df = st.zscore(df)\n",
    "    return df\n",
    "    \n",
    "class CalculateMeteics:\n",
    "    def __init__(self, raw_count_file, impute_count_file, prefix, metric):\n",
    "        self.impute_count_file = impute_count_file\n",
    "        self.raw_count = pd.read_csv(raw_count_file, header = 0, sep=\"\\t\")\n",
    "        self.raw_count.columns = [x.upper() for x in self.raw_count.columns]\n",
    "        self.raw_count = self.raw_count.T\n",
    "        self.raw_count = self.raw_count.loc[~self.raw_count.index.duplicated(keep='first')].T\n",
    "        self.raw_count = self.raw_count.fillna(1e-20)\n",
    "        \n",
    "        self.impute_count = pd.read_csv(impute_count_file, header = 0, index_col = 0)\n",
    "        self.impute_count.columns = [x.upper() for x in self.impute_count.columns]\n",
    "        self.impute_count = self.impute_count.T\n",
    "        self.impute_count = self.impute_count.loc[~self.impute_count.index.duplicated(keep='first')].T\n",
    "        self.impute_count = self.impute_count.fillna(1e-20)\n",
    "        self.prefix = prefix\n",
    "        self.metric = metric\n",
    "        \n",
    "    def SSIM(self, raw, impute, scale = 'scale_max'):\n",
    "        if scale == 'scale_max':\n",
    "            raw = scale_max(raw)\n",
    "            impute = scale_max(impute)\n",
    "        else:\n",
    "            print ('Please note you do not scale data by scale max')\n",
    "        if raw.shape[0] == impute.shape[0]:\n",
    "            result = pd.DataFrame()\n",
    "            for label in raw.columns:\n",
    "                if label not in impute.columns:\n",
    "                    ssim = 0\n",
    "                else:\n",
    "                    raw_col =  raw.loc[:,label]\n",
    "                    impute_col = impute.loc[:,label]\n",
    "                    impute_col = impute_col.fillna(1e-20)\n",
    "                    raw_col = raw_col.fillna(1e-20)\n",
    "                    M = [raw_col.max(),impute_col.max()][raw_col.max()>impute_col.max()]\n",
    "                    raw_col_2 = np.array(raw_col)\n",
    "                    raw_col_2 = raw_col_2.reshape(raw_col_2.shape[0],1)\n",
    "                    impute_col_2 = np.array(impute_col)\n",
    "                    impute_col_2 = impute_col_2.reshape(impute_col_2.shape[0],1)\n",
    "                    ssim = cal_ssim(raw_col_2,impute_col_2,M)\n",
    "                \n",
    "                ssim_df = pd.DataFrame(ssim, index=[\"SSIM\"],columns=[label])\n",
    "                result = pd.concat([result, ssim_df],axis=1)\n",
    "        else:\n",
    "            print(\"columns error\")\n",
    "        return result\n",
    "            \n",
    "    def PCC(self, raw, impute, scale = None):\n",
    "        if raw.shape[0] == impute.shape[0]:\n",
    "            result = pd.DataFrame()\n",
    "            for label in raw.columns:\n",
    "                if label not in impute.columns:\n",
    "                    pearsonr = 0\n",
    "                else:\n",
    "                    raw_col =  raw.loc[:,label]\n",
    "                    impute_col = impute.loc[:,label]\n",
    "                    impute_col = impute_col.fillna(1e-20)\n",
    "                    raw_col = raw_col.fillna(1e-20)\n",
    "                    pearsonr, _ = st.pearsonr(raw_col,impute_col)\n",
    "                pearson_df = pd.DataFrame(pearsonr, index=[\"PCC\"],columns=[label])\n",
    "                result = pd.concat([result, pearson_df],axis=1)\n",
    "        else:\n",
    "            print(\"columns error\")\n",
    "        return result\n",
    "    \n",
    "    def JS(self, raw, impute, scale = 'scale_plus'):\n",
    "        if scale == 'scale_plus':\n",
    "            raw = scale_plus(raw)\n",
    "            impute = scale_plus(impute)\n",
    "        else:\n",
    "            print ('Please note you do not scale data by plus')    \n",
    "        if raw.shape[0] == impute.shape[0]:\n",
    "            result = pd.DataFrame()\n",
    "            for label in raw.columns:\n",
    "                if label not in impute.columns:\n",
    "                    JS = 1\n",
    "                else:\n",
    "                    raw_col =  raw.loc[:,label]\n",
    "                    impute_col = impute.loc[:,label]\n",
    "                    raw_col = raw_col.fillna(1e-20)\n",
    "                    impute_col = impute_col.fillna(1e-20)\n",
    "                    M = (raw_col + impute_col)/2\n",
    "                    JS = 0.5*st.entropy(raw_col,M)+0.5*st.entropy(impute_col,M)\n",
    "                JS_df = pd.DataFrame(JS, index=[\"JS\"],columns=[label])\n",
    "                result = pd.concat([result, JS_df],axis=1)\n",
    "        else:\n",
    "            print(\"columns error\")\n",
    "        return result\n",
    "    \n",
    "    def RMSE(self, raw, impute, scale = 'zscore'):\n",
    "        if scale == 'zscore':\n",
    "            raw = scale_z_score(raw)\n",
    "            impute = scale_z_score(impute)\n",
    "        else:\n",
    "            print ('Please note you do not scale data by zscore')\n",
    "        if raw.shape[0] == impute.shape[0]:\n",
    "            result = pd.DataFrame()\n",
    "            for label in raw.columns:\n",
    "                if label not in impute.columns:\n",
    "                    RMSE = 1.5   \n",
    "                else:\n",
    "                    raw_col =  raw.loc[:,label]\n",
    "                    impute_col = impute.loc[:,label]\n",
    "                    impute_col = impute_col.fillna(1e-20)\n",
    "                    raw_col = raw_col.fillna(1e-20)\n",
    "                    RMSE = np.sqrt(((raw_col - impute_col) ** 2).mean())\n",
    "\n",
    "                RMSE_df = pd.DataFrame(RMSE, index=[\"RMSE\"],columns=[label])\n",
    "                result = pd.concat([result, RMSE_df],axis=1)\n",
    "        else:\n",
    "            print(\"columns error\")\n",
    "        return result       \n",
    "        \n",
    "    def compute_all(self):\n",
    "        raw = self.raw_count\n",
    "        impute = self.impute_count\n",
    "        prefix = self.prefix\n",
    "        SSIM = self.SSIM(raw,impute)\n",
    "        Pearson = self.PCC(raw, impute)\n",
    "        JS = self.JS(raw, impute)\n",
    "        RMSE = self.RMSE(raw, impute)\n",
    "        \n",
    "        result_all = pd.concat([Pearson, SSIM, RMSE, JS],axis=0)\n",
    "        result_all.T.to_csv(prefix + \"_Metrics.txt\", sep='\\t', header = 1, index = 1)\n",
    "        self.accuracy = result_all\n",
    "        return result_all\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "import os\n",
    "PATH = 'FigureData/Figure2/'\n",
    "DirFiles = os.listdir(PATH)\n",
    "CountInsuteDir = 'DataUpload/'\n",
    "\n",
    "def CalDataMetric(Data):\n",
    "    print ('We are calculating the : ' + Data + '\\n')\n",
    "    raw_count_file = CountInsuteDir + Data + '/Insitu_count.txt'\n",
    "    metric = ['PCC','SSIM','RMSE','JS']\n",
    "    impute_count_dir = PATH + Data\n",
    "    impute_count = os.listdir(impute_count_dir)\n",
    "    impute_count = [x for x in impute_count if x [-3:] == 'csv']\n",
    "    if len(impute_count)!=0:\n",
    "        for impute_count_file in impute_count:\n",
    "            if 'result_Tangram.csv' in impute_count_file:\n",
    "                os.system('mv ' + impute_count_dir + '/result_Tangram.csv ' + impute_count_dir + '/Tangram_impute.csv')\n",
    "            prefix = impute_count_file.split('_')[0]\n",
    "            prefix = impute_count_dir + '/' + prefix\n",
    "            impute_count_file = impute_count_dir + '/' + impute_count_file\n",
    "            if not os.path.isfile(prefix + '_Metrics.txt'):\n",
    "                print (impute_count_file)\n",
    "                CM = CalculateMeteics(raw_count_file = raw_count_file, impute_count_file = impute_count_file, prefix = prefix, metric = metric)\n",
    "                CM.compute_all()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We are calculating the : Dataset4\n",
      "\n"
     ]
    }
   ],
   "source": [
    "DataSets = ['Dataset4']\n",
    "with multiprocessing.Pool(10) as pool:\n",
    "    pool.map(CalDataMetric, DataSets)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DataSet Boxplot for 4 mertrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_boxplot(PATH,Data,metric,Tools,outdir):\n",
    "    palette = [\"#F5A8C7\", '#F9EC31', \"#D6DE23\", \"#988DC3\", \"#BBA8D1\", \"#A2CBCF\", \"#7BD1F1\", \"#79c06e\"]\n",
    "    font = {'family':'DejaVu Sans','weight':'normal','size':15}\n",
    "    plt.figure(figsize=(18,16), dpi= 80)\n",
    "    result = pd.DataFrame()\n",
    "    metrics = metric\n",
    "    for tool in Tools:\n",
    "        result_metrics = pd.read_csv(PATH + Data + '/' + tool + '_Metrics.txt', sep = '\\t', header = 0, index_col = 0)\n",
    "        result_metrics['tool'] = tool\n",
    "        result = pd.concat([result, result_metrics],axis=0) \n",
    "    n = 221\n",
    "    for method in metrics:\n",
    "        ax1 = plt.subplot(n)\n",
    "        ax1 = sns.barplot(x = method, y = \"tool\", data = result, ci = 95, palette = palette)\n",
    "        ax1.set_xlabel(method)\n",
    "        ax1.spines['top'].set_visible(False)\n",
    "        ax1.spines['right'].set_visible(False)\n",
    "        n = n + 1 \n",
    "\n",
    "    OutPdf = outdir\n",
    "    if not os.path.exists(OutPdf):\n",
    "        os.mkdir(OutPdf)\n",
    "    plt.savefig(OutPdf + Data + \"_metrics.pdf\")\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x1280 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "PATH = 'FigureData/Figure2/'\n",
    "metric = ['PCC', 'SSIM', 'JS', 'RMSE']\n",
    "Data = 'Dataset4'\n",
    "Tools = ['Tangram', 'gimVI', 'SpaGE', 'Seurat', 'SpaOTsc', 'novoSpaRc', 'LIGER', 'stPlus']\n",
    "outdir = 'FigureData/Figure2/Dataset4/'\n",
    "if not os.path.exists(outdir):\n",
    "    os.system('mkdir ' + outdir)\n",
    "plot_boxplot(PATH, Data, metric,Tools,outdir)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Calculated Accuracy score for every datasets of each methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "45\n"
     ]
    }
   ],
   "source": [
    "###This script is used for rank get the rank score for each method\n",
    "\n",
    "def get_score(Result):\n",
    "    Result = Result.fillna(0)\n",
    "    tools_num = Result.shape[0]\n",
    "    Tools_score=[]\n",
    "    methods = list(Result.index)\n",
    "    score_col = []\n",
    "    list_up = list(range(1,Result.shape[1]+1))\n",
    "    list_down  = list(range(Result.shape[1],0,-1))\n",
    "    \n",
    "    for method in methods:\n",
    "        if method == 'PCC' or method == 'SSIM':\n",
    "            Tools_score.append(pd.Series(list_down, index=Result.loc[method,:].sort_values(ascending=False).index))\n",
    "            \n",
    "        if method == 'JS' or method == 'RMSE':\n",
    "            Tools_score.append(pd.Series(list_up, index=Result.loc[method,:].sort_values(ascending=False).index))\n",
    "        score_col.append(method)\n",
    "        \n",
    "    score=pd.concat([m for m in Tools_score],axis=1)\n",
    "    score.columns = score_col\n",
    "    score = score/Result.shape[1]\n",
    "    return score\n",
    "\n",
    "def make_score(path, dataset_all, Tools, path_output):\n",
    "    Tools_data=[x for x in range(len(Tools))]\n",
    "    for dataset in dataset_all:\n",
    "        for i in range(len(Tools)):\n",
    "            File = path + '/' + dataset + '/' + Tools[i] + '_Metrics.txt'\n",
    "            if os.path.isfile(File): \n",
    "                Tools_data[i] = pd.read_table(path + '/' + dataset + '/' + Tools[i] + '_Metrics.txt',sep='\\t',index_col=0, header=0)\n",
    "                Tools_data[i] = Tools_data[i].mean()\n",
    "                Tools_data[i]['Tool'] = Tools[i]\n",
    "            else:\n",
    "                Tools_data[i] = pd.DataFrame([-2, -2, 10, 10], columns = ['Genes'], index = ['PCC', 'SSIM', 'RMSE', 'JS']).T\n",
    "                Tools_data[i] = Tools_data[i].mean()\n",
    "                Tools_data[i]['Tool'] = Tools[i]\n",
    "        Result=pd.concat([m for m in Tools_data], axis=1)\n",
    "        Result.columns = Result.loc[[\"Tool\"],:].values.flatten()\n",
    "        Result.drop('Tool', axis = 0, inplace = True)    \n",
    "            \n",
    "        score = get_score(Result)\n",
    "        score.to_csv(path_output + dataset + \"_score.txt\", header=1, index=1)\n",
    "\n",
    "path = 'FigureData/Figure2/Metrics/'\n",
    "path_output = 'FigureData/Figure2/Metrics/Accuracy_Rank/'\n",
    "if not os.path.exists(path_output):\n",
    "    os.mkdir(path_output)\n",
    "Tools = ['Tangram', 'gimVI', 'SpaGE', 'Seurat', 'SpaOTsc', 'novoSpaRc', 'LIGER', 'stPlus']\n",
    "DirFiles = os.listdir(path)\n",
    "dataset_all = [x for x in DirFiles if x[:4] == 'Data']\n",
    "print (len(dataset_all))\n",
    "make_score(path, dataset_all, Tools, path_output)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Accuracy for one datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def make_plot_one_dataset(path, Data,order,palette):\n",
    "    dataset = pd.read_csv(path + '/Accuracy_Rank/' + Data + '_score.txt', header = 0, index_col = 0)\n",
    "\n",
    "    dataset_mer = pd.concat([dataset.iloc[:,0],dataset.iloc[:,1],dataset.iloc[:,2],dataset.iloc[:,3]], axis = 0)\n",
    "    dataset_mer  = pd.DataFrame(dataset_mer,index =dataset_mer.index.values,columns=[Data])\n",
    "    axes =sns.violinplot(x = Data,y = dataset_mer.index.values, data = dataset_mer ,order = order,palette = palette, width = 0.9)\n",
    "    axes.set_xlabel(Data, fontsize = 10)\n",
    "    axes.set_ylabel('', fontsize = 10)\n",
    "    axes.spines['top'].set_visible(False)\n",
    "    axes.spines['right'].set_visible(False)\n",
    "    plt.xticks(fontsize = 8)\n",
    "    plt.yticks(fontsize = 8)\n",
    "    plt.savefig(path + 'Accuracy_Rank/'+ Data + '_violinplot.pdf')\n",
    "    plt.show()\n",
    "\n",
    "    \n",
    "path = 'FigureData/Figure2/Metrics/'\n",
    "dataset='Data4'\n",
    "order = ['Tangram', 'gimVI', 'SpaGE', 'Seurat', 'SpaOTsc', 'novoSpaRc', 'LIGER', 'stPlus']\n",
    "palette = [\"#F5A8C7\", '#F9EC31', \"#D6DE23\", \"#988DC3\", \"#BBA8D1\", \"#A2CBCF\", \"#7BD1F1\", \"#79c06e\"]\n",
    "make_plot_one_dataset(path, dataset,order,palette)\n",
    "\n",
    "path = 'FigureData/Figure2/Metrics/'\n",
    "dataset='Data42'\n",
    "order = ['Tangram', 'gimVI', 'SpaGE', 'Seurat', 'SpaOTsc', 'novoSpaRc', 'LIGER', 'stPlus']\n",
    "palette = [\"#F5A8C7\", '#F9EC31', \"#D6DE23\", \"#988DC3\", \"#BBA8D1\", \"#A2CBCF\", \"#7BD1F1\", \"#79c06e\"]\n",
    "make_plot_one_dataset(path, dataset,order,palette)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Accuracy for image, seq based"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "45\n",
      "28\n",
      "17\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def make_all_score(path, dataset_all):\n",
    "    score_all = pd.DataFrame()\n",
    "    for dataset in dataset_all:\n",
    "        a = pd.read_csv(path + '/Accuracy_Rank/'+dataset+\"_score.txt\",header=0,index_col=0)\n",
    "        a['DataSet'] = dataset\n",
    "        score_all=pd.concat([score_all,a],axis=0)\n",
    "    return score_all\n",
    "\n",
    "\n",
    "def plot_all(df, name, order, palette, path):\n",
    "    df = df[['PCC', 'SSIM', 'RMSE', 'JS']]\n",
    "    df_all = pd.DataFrame(df.sum(axis=1).values,index = df.index.values,columns=['merge'])\n",
    "    df_all = df_all/4\n",
    "    \n",
    "    plt.figure(figsize=(8, 6))\n",
    "    axes =sns.boxplot(x= 'merge',y= df_all.index.values, data=df_all ,palette=palette,order=order,flierprops = dict(marker='o', markersize=3))\n",
    "    axes.set_xlabel(name, fontsize=10)\n",
    "    axes.set_ylabel('', fontsize=10)\n",
    "    axes.spines['top'].set_visible(False)\n",
    "    axes.spines['right'].set_visible(False)\n",
    "    plt.xticks(fontsize=8)\n",
    "    plt.yticks(fontsize=8)\n",
    "    plt.savefig(path + \"/Accuracy_Rank/\" + name + '_boxplot.pdf')\n",
    "    plt.show()\n",
    "\n",
    "path = 'FigureData/Figure2/Metrics/'\n",
    "os.popen('mkdir ' + path + 'Accuracy_Rank')\n",
    "path_output = path + '/Accuracy_Rank/'\n",
    "order = ['Tangram', 'gimVI', 'SpaGE', 'Seurat', 'SpaOTsc', 'novoSpaRc', 'LIGER', 'stPlus']\n",
    "Tools= ['Tangram', 'gimVI', 'SpaGE', 'Seurat', 'SpaOTsc', 'novoSpaRc', 'LIGER', 'stPlus']\n",
    "palette = [\"#F5A8C7\", '#F9EC31', \"#D6DE23\", \"#988DC3\", \"#BBA8D1\", \"#A2CBCF\", \"#7BD1F1\", \"#79c06e\"]\n",
    "\n",
    "DirFiles = os.listdir(path)\n",
    "DataSets = [x for x in DirFiles if x[:4] == 'Data']\n",
    "image_based_dataset = ['Data1', 'Data2', 'Data3', 'Data4', 'Data5', 'Data6', 'Data7', 'Data8', 'Data9', \n",
    "            'Data10', 'Data11', 'Data12', 'Data13', 'Data14', 'Data15', 'Data16', 'Data17']\n",
    "seq_based_dataset = [x for x in DataSets if x not in image_based_dataset]\n",
    "print (len(DataSets))\n",
    "print (len(seq_based_dataset))\n",
    "print (len(image_based_dataset))\n",
    "\n",
    "\n",
    "image_based = make_all_score(path, image_based_dataset)\n",
    "image_based.to_csv(path + \"/Accuracy_Rank/image_based_score.txt\",header=1, index=1)\n",
    "\n",
    "seq_based = make_all_score(path, seq_based_dataset)\n",
    "seq_based.to_csv(path + \"/Accuracy_Rank/seq_based_score.txt\",header=1, index=1)\n",
    "\n",
    "plot_image = pd.read_csv(path + \"/Accuracy_Rank/image_based_score.txt\", header = 0, index_col = 0)\n",
    "plot_image.loc[plot_image['DataSet'] == 'Data8', 'JS'] = 0\n",
    "plot_seq = pd.read_csv(path + \"/Accuracy_Rank/seq_based_score.txt\", header = 0, index_col = 0)\n",
    "\n",
    "plot_all(plot_seq, 'seq-based', order, palette, path)\n",
    "plot_all(plot_image, 'image-based', order, palette, path)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Accuracy for all datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "path = 'FigureData/Figure2/Metrics/'\n",
    "all_based = make_all_score(path, DataSets)\n",
    "all_based.to_csv(path + \"/Accuracy_Rank/Score.txt\", header = 1, index = 1)\n",
    "plot_data = pd.read_csv(path + \"/Accuracy_Rank/Score.txt\", header = 0, index_col = 0)\n",
    "# JS of Dataset8 is Inf for all methods, because the spatial data has been scaled.\n",
    "plot_data.loc[plot_data['DataSet'] == 'Data8', 'JS'] = 0\n",
    "plot_all(plot_data, 'Accuracy Score', order, palette, path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Accuracy for MERFISH datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_all(df, name, order, palette, path):\n",
    "    df = df[['PCC', 'SSIM', 'RMSE', 'JS']]\n",
    "    df_all = pd.DataFrame(df.sum(axis=1).values,index = df.index.values,columns=['merge'])\n",
    "    df_all = df_all/4\n",
    "    \n",
    "    plt.figure(figsize=(8, 6))\n",
    "    axes = sns.boxplot(x= 'merge',y= df_all.index.values, data = df_all ,palette=palette,order=order,flierprops = dict(marker='o', markersize=3))\n",
    "    axes = sns.swarmplot(x = 'merge', y = df_all.index.values, data = df_all, order = order, color = \"black\", size = 7)\n",
    "    axes.set_xlabel(name, fontsize=10)\n",
    "    axes.set_ylabel('', fontsize=10)\n",
    "    axes.spines['top'].set_visible(False)\n",
    "    axes.spines['right'].set_visible(False)\n",
    "    plt.xticks(fontsize=8)\n",
    "    plt.yticks(fontsize=8)\n",
    "    plt.savefig(path + \"/Accuracy_Rank/\" + name + '_boxplot.pdf')\n",
    "    plt.show()\n",
    "    \n",
    "order = ['Tangram', 'gimVI', 'SpaGE', 'Seurat', 'SpaOTsc', 'novoSpaRc', 'LIGER', 'stPlus']\n",
    "palette = [\"#F5A8C7\", '#F9EC31', \"#D6DE23\", \"#988DC3\", \"#BBA8D1\", \"#A2CBCF\", \"#7BD1F1\", \"#79c06e\"]    \n",
    "path = 'FigureData/Figure2/Metrics/'\n",
    "MERFISHBased = ['Data6', 'Data7', 'Data8', 'Data9']\n",
    "MERFISH_based = make_all_score(path,MERFISHBased)\n",
    "MERFISH_based.to_csv(path + \"/Accuracy_Rank/MERFISH_score.txt\", header = 1, index = 1)\n",
    "plot_MERFISH = pd.read_csv(path + \"/Accuracy_Rank/MERFISH_score.txt\", header = 0, index_col = 0)\n",
    "plot_MERFISH['Tool'] = plot_MERFISH.index\n",
    "plot_MERFISH.index = plot_MERFISH['Tool'] + '_' + plot_MERFISH['DataSet']\n",
    "\n",
    "### Removed LIGER and gimVI's scores for Data8 because an error occurred when making predictions for Dataset 8 using these two tools.\n",
    "\n",
    "plot_MERFISH = plot_MERFISH.drop('LIGER_Data8', axis = 0)\n",
    "plot_MERFISH = plot_MERFISH.drop('gimVI_Data8', axis = 0)\n",
    "\n",
    "plot_MERFISH.index = plot_MERFISH['Tool']\n",
    "plot_MERFISH = plot_MERFISH[['PCC', 'SSIM', 'RMSE', 'JS', 'DataSet']]\n",
    "plot_MERFISH.loc[plot_MERFISH['DataSet'] == 'Data8', 'JS'] = 0\n",
    "plot_all(plot_MERFISH, 'MERFISHScore', order, palette, path)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}