Lupus.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import scipy as sp\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "sns.set_theme()\n",
    "\n",
    "from tqdm import tqdm\n",
    "\n",
    "import scanpy as sc\n",
    "\n",
    "from causarray import *\n",
    "\n",
    "import os\n",
    "path_data = 'data/lupus/'\n",
    "path_result = 'results/Lupus/'\n",
    "os.makedirs(path_result, exist_ok=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Preprocess and save data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AnnData object with n_obs × n_vars = 1263676 × 32738\n",
      "    obs: 'SLE_status', 'ind_cov', 'batch_cov', 'pop_cov', 'cg_cov', 'ct_cov', 'Age', 'Sex', 'Processing_Cohort', 'L3'\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "256"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "adata = sc.read_h5ad('data/lupus/raw.h5ad')\n",
    "print(adata)\n",
    "\n",
    "# 261 individuals\n",
    "adata = adata[adata.obs['pop_cov'].isin(['Asian', 'European']),:]\n",
    "# 256 individuals\n",
    "adata.obs['cg_pop_cov'] = adata.obs['cg_cov'].astype(str) + '-' + adata.obs['pop_cov'].astype(str)\n",
    "adata.obs['cg_pop_cov'] = adata.obs['cg_pop_cov'].astype(\"category\")\n",
    "\n",
    "gene_names = np.array(adata.var_names, dtype=str)\n",
    "\n",
    "sc.pp.normalize_total(adata, target_sum=1e4)\n",
    "sc.pp.log1p(adata)\n",
    "adata.obs.groupby(['ind_cov']).count().shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T4\n",
      "\t shape: (375885, 32738) 32738\n",
      "\t ind: 256\n",
      "(375885, 2000) (375885, 6) (375885,)\n",
      "cM\n",
      "\t shape: (302649, 32738) 32738\n",
      "\t ind: 256\n",
      "(302649, 2000) (302649, 6) (302649,)\n",
      "B\n",
      "\t shape: (149861, 32738) 32738\n",
      "\t ind: 254\n",
      "(149861, 2000) (149861, 6) (149861,)\n",
      "T8\n",
      "\t shape: (242677, 32738) 32738\n",
      "\t ind: 256\n",
      "(242677, 2000) (242677, 6) (242677,)\n",
      "NK\n",
      "\t shape: (90190, 32738) 32738\n",
      "\t ind: 256\n",
      "(90190, 2000) (90190, 6) (90190,)\n",
      "ncM\n",
      "\t shape: (48196, 32738) 32738\n",
      "\t ind: 256\n",
      "(48196, 2000) (48196, 6) (48196,)\n",
      "Prolif\n",
      "\t shape: (7904, 32738) 32738\n",
      "\t ind: 255\n",
      "(7904, 2000) (7904, 6) (7904,)\n",
      "cDC\n",
      "\t shape: (18032, 32738) 32738\n",
      "\t ind: 254\n",
      "(18032, 2000) (18032, 6) (18032,)\n",
      "pDC\n",
      "\t shape: (5206, 32738) 32738\n",
      "\t ind: 254\n",
      "(5206, 2000) (5206, 6) (5206,)\n",
      "PB\n",
      "\t shape: (1372, 32738) 32738\n",
      "\t ind: 212\n",
      "(1372, 2000) (1372, 6) (1372,)\n",
      "Progen\n",
      "\t shape: (800, 32738) 32738\n",
      "\t ind: 215\n",
      "(800, 2000) (800, 6) (800,)\n"
     ]
    }
   ],
   "source": [
    "from sklearn.preprocessing import OrdinalEncoder, OneHotEncoder\n",
    "col_covariate = ['Sex','Processing_Cohort','pop_cov','SLE_status']\n",
    "\n",
    "n_hvg = 2000\n",
    "for celltype in adata.obs['cg_cov'].unique():\n",
    "    idx = adata.obs['cg_cov'] == celltype\n",
    "    _adata = adata[idx].copy()\n",
    "    \n",
    "    sc.pp.highly_variable_genes(_adata, n_top_genes=n_hvg)\n",
    "    gene_names = _adata.var.index[_adata.var['highly_variable']]\n",
    "    \n",
    "    count = _adata.raw.X[:,np.in1d(_adata.raw.var_names.tolist(), gene_names)]\n",
    "    \n",
    "    _df = _adata.obs\n",
    "    uni_ind = np.unique(_df['ind_cov'])\n",
    "    \n",
    "    print(celltype)\n",
    "    print('\\t shape:', _adata.raw.X.shape, len(_adata.raw.var_names))\n",
    "    print('\\t ind:', len(uni_ind))    \n",
    "\n",
    "    meta = _df.iloc[:,:]\n",
    "    \n",
    "    enc = OrdinalEncoder()    \n",
    "    X = enc.fit_transform(meta[['Sex','pop_cov','SLE_status']])\n",
    "        \n",
    "    enc = OneHotEncoder(drop='first')\n",
    "    _X = enc.fit_transform(meta[['Processing_Cohort']])\n",
    "    \n",
    "    X = np.c_[X[:,:-1], _X.toarray(), X[:,-1:]]\n",
    "    \n",
    "    Y = count.toarray()\n",
    "    ind = _df['ind_cov']\n",
    "    print(Y.shape, X.shape, ind.shape)\n",
    "    \n",
    "    with open(path_data + 'data_{}.npz'.format(celltype), 'wb') as f:\n",
    "        np.savez(f, X=X, Y=Y, ind=ind, gene_names=gene_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(256, 8) (256, 1255) (256, 1255)\n"
     ]
    }
   ],
   "source": [
    "celltypes = ['T4', 'cM', 'B', 'T8', 'NK']\n",
    "celltype = celltypes[0]\n",
    "\n",
    "\n",
    "with open(path_data + 'data_{}.npz'.format(celltype), 'rb') as f:\n",
    "    res = np.load(f, allow_pickle=True)\n",
    "    W = res['X']\n",
    "    ind = res['ind']\n",
    "    gene_names = res['gene_names']\n",
    "    Y = res['Y']\n",
    "    W = W * 2 - 1\n",
    "\n",
    "groups = ind\n",
    "_ndx = np.argsort(groups)\n",
    "_id, _pos, g_count  = np.unique(\n",
    "    groups[_ndx], return_index=True, return_counts=True)\n",
    "\n",
    "Y = Y[_ndx]\n",
    "W = W[_ndx]\n",
    "\n",
    "Yg = np.add.reduceat(Y, _pos, axis=0)\n",
    "Wg = W[_pos]\n",
    "Wg = np.c_[np.ones(Wg.shape[0]), np.log(np.sum(Yg, axis=1)),  Wg]\n",
    "Wg = Wg / np.sqrt(np.sum(Wg**2, 0, keepdims=True)) * np.sqrt(Wg.shape[0])\n",
    "Wg[:,-1] = (Wg[:,-1]+1)/2\n",
    "\n",
    "id_genes = np.any(Yg!=0, axis=0) & (np.sum(Yg>0, axis=0)>=10)\n",
    "\n",
    "W = np.repeat(Wg, g_count, axis=0)\n",
    "Y = Y[:,id_genes]\n",
    "Yg = Yg[:,id_genes]\n",
    "print(Wg.shape, Yg.shape, Yg.shape)\n",
    "\n",
    "resid = fit_glm(Yg, Wg[:,:-1], np.zeros((Yg.shape[0],0)), family='nb')[-1]\n",
    "W = Wg[:,:-1]\n",
    "A = Wg[:,-1]\n",
    "df_glm_p, df_glm_nb = glm_test(Yg, W, A)\n",
    "df_glm_p.index = gene_names[id_genes]\n",
    "df_glm_nb.index = gene_names[id_genes]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ATE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "144.0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_ATE = ATE(Yg, W, A, W[:,:4], B=10000, alpha=0.05, c=0.1, family='nb', penalty='none')\n",
    "df_ATE.to_csv(path_result+'{}_ATE.csv'.format(celltype), index=False)\n",
    "df_ATE['rej'].sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SATE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "146.0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_SATE = SATE(Yg, W, A, W[:,:4], B=10000, alpha=0.05, c=0.1, family='nb', penalty='none')\n",
    "df_SATE.to_csv(path_result+'{}_SATE.csv'.format(celltype), index=False)\n",
    "df_SATE['rej'].sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# QTE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "81.0"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_QTE = QTE(\n",
    "    Yg, W, A, W[:,:4], B=10000, alpha=0.05, c=0.1, family='nb', penalty='none'\n",
    "    )\n",
    "df_QTE.to_csv(path_result+'{}_QTE.csv'.format(celltype), index=False)\n",
    "\n",
    "df_QTE['rej'].sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SQTE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "54.0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_SQTE = SQTE(\n",
    "    Yg, W, A, W_D=W[:,:4], B=10000, alpha=0.05, c=0.1, family='nb', penalty='none'\n",
    "    )\n",
    "df_SQTE.to_csv(path_result+'{}_SQTE.csv'.format(celltype), index=False)\n",
    "df_SQTE['rej'].sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_ATE = pd.read_csv(path_result+'{}_ATE.csv'.format(celltype))\n",
    "df_STE = pd.read_csv(path_result+'{}_SATE.csv'.format(celltype))\n",
    "df_QTE = pd.read_csv(path_result+'{}_QTE.csv'.format(celltype))\n",
    "df_SQTE = pd.read_csv(path_result+'{}_SQTE.csv'.format(celltype))\n",
    "df_ATE.index = gene_names[id_genes]\n",
    "df_STE.index = gene_names[id_genes]\n",
    "df_QTE.index = gene_names[id_genes]\n",
    "df_SQTE.index = gene_names[id_genes]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(144.0, 146.0, 81.0, 54.0)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_ATE['rej'].sum(), df_STE['rej'].sum(), df_QTE['rej'].sum(), df_SQTE['rej'].sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60, 56, 49, 29)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(df_glm_nb['q_values']<0.1), np.sum((df_glm_nb['q_values']<0.1)&(df_ATE['rej']==1)), np.sum((df_glm_nb['q_values']<0.1)&(df_STE['rej']==1)), np.sum((df_glm_nb['q_values']<0.1)&(df_QTE['rej']==1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Upset plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import upsetplot\n",
    "from upsetplot import UpSet\n",
    "from upsetplot import from_indicators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "methods = ['ATE','STE','QTE','SQTE']\n",
    "discoveries = pd.DataFrame(np.c_[df_ATE['rej'], df_STE['rej'], df_QTE['rej'], df_SQTE['rej']\n",
    "], \n",
    "    columns = methods)\n",
    "discoveries.fillna(0, inplace=True)\n",
    "discoveries = (discoveries==1)\n",
    "discoveries = discoveries.loc[np.any(discoveries, axis=1)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x288 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set_theme(style=\"white\", rc={\"axes.spines.right\": False, \"axes.spines.top\": False, \"axes.spines.left\": False, \"axes.spines.bottom\": False})\n",
    "fig = plt.figure(figsize=(10, 4))\n",
    "upsetplot.plot(from_indicators(discoveries).groupby(methods[::-1]).count(),\n",
    "      sort_categories_by='input', sort_by='cardinality',\n",
    "      fig=fig,  element_size=None, show_counts=True\n",
    "      )\n",
    "plt.savefig('figures/Lupus_upset_{}.pdf'.format(celltype), bbox_inches='tight', dpi=300)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy as sp\n",
    "def summarize(Y, resid, A):\n",
    "    res_diff = np.r_[\n",
    "        (np.abs(np.median(resid[A==1]) - (np.median(resid[A==0]))))/1000,\n",
    "        np.abs(np.mean((resid+Y)[A==1]) - np.mean((resid+Y)[A==0]))/np.std((resid+Y)[A==0]),\n",
    "        np.abs(np.median((resid+Y)[A==1]) - np.median((resid+Y)[A==0]))/np.std((resid+Y)[A==0])\n",
    "    ]\n",
    "\n",
    "    res_overall = np.r_[\n",
    "        np.mean(Y==0), \n",
    "        \n",
    "    ]\n",
    "\n",
    "    res = np.r_[res_diff, res_overall]\n",
    "    return res\n",
    "\n",
    "idx_list = [\n",
    "    np.where((df_ATE['rej']==1)&(df_STE['rej']==1)&(df_QTE['rej']==1)&(df_SQTE['rej']==1))[0],\n",
    "    np.where((df_ATE['rej']!=1)&(df_STE['rej']!=1)&(df_QTE['rej']==1)&(df_SQTE['rej']==1))[0],\n",
    "    np.where((df_ATE['rej']==1)&(df_STE['rej']==1)&(df_QTE['rej']!=1)&(df_SQTE['rej']!=1))[0]\n",
    "]\n",
    "\n",
    "res_all = []\n",
    "for i, idx in enumerate(idx_list):\n",
    "    for j in idx:\n",
    "        res = np.r_[summarize(Yg[:,j], resid[:,j], A), j, i]\n",
    "        \n",
    "        res_all.append(res)\n",
    "res_all = np.array(res_all)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                      Absolute difference\\nof residual median  \\\n",
      "Test                                                            \n",
      "ATE & STE only (84)                                  0.009100   \n",
      "Common (25)                                          0.363351   \n",
      "QTE & SQTE only (23)                                 0.012070   \n",
      "\n",
      "                      Absolute difference\\nof fitted response mean  \\\n",
      "Test                                                                 \n",
      "ATE & STE only (84)                                       0.493550   \n",
      "Common (25)                                               0.677256   \n",
      "QTE & SQTE only (23)                                      0.376370   \n",
      "\n",
      "                      Absolute difference\\nof fitted response median  \\\n",
      "Test                                                                   \n",
      "ATE & STE only (84)                                         0.289310   \n",
      "Common (25)                                                 0.352550   \n",
      "QTE & SQTE only (23)                                        0.435775   \n",
      "\n",
      "                      Proportion of\\nzero counts      j  count  \n",
      "Test                                                            \n",
      "ATE & STE only (84)                          0.0  622.5   84.0  \n",
      "Common (25)                                  0.0  452.0   25.0  \n",
      "QTE & SQTE only (23)                         0.0  774.0   23.0  \n"
     ]
    }
   ],
   "source": [
    "col_names = ['Absolute difference\\nof residual median',\n",
    "    'Absolute difference\\nof fitted response mean',\n",
    "    'Absolute difference\\nof fitted response median',\n",
    "    'Proportion of\\nzero counts', 'j', 'Test']\n",
    "_df = pd.DataFrame(res_all, columns=col_names)\n",
    "_df['Test'] = _df['Test'].map(\n",
    "    {0: 'Common ({})'.format(np.sum(_df['Test']==0)), 1: 'QTE & SQTE only ({})'.format(np.sum(_df['Test']==1)), \n",
    "    2: 'ATE & STE only ({})'.format(np.sum(_df['Test']==2))})\n",
    "_df['count'] = _df.groupby('Test')['Test'].transform('count')\n",
    "\n",
    "# _df.to_csv(path_result+'{}_summary.csv'.format(gRNA_name), index=False)\n",
    "\n",
    "print(_df.groupby('Test').median())\n",
    "_df = _df.melt(id_vars=['j', 'Test'], value_vars=col_names[:-2], value_name='Value', var_name='Metric')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1008x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set(font_scale=1.4)\n",
    "fig, ax = plt.subplots(1, 1, figsize=(14,6))\n",
    "\n",
    "sns.barplot(_df, y='Value', x='Metric', hue='Test', ax=ax)\n",
    "plt.ylim([0,1.1])\n",
    "\n",
    "ax.legend(title='Significant Tests')\n",
    "\n",
    "fig.tight_layout()\n",
    "fig.subplots_adjust(top=0.88)\n",
    "plt.savefig('figures/lupus_{}_metric.pdf'.format(celltype), bbox_inches='tight', pad_inches=0, dpi=300)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Distributions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1080x648 with 15 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib.colors import to_rgba\n",
    "n_col = 5\n",
    "colors = [\n",
    "    sns.color_palette(\"muted\")[1], sns.color_palette(\"muted\")[0]\n",
    "]\n",
    "sns.set(font_scale=1.5)\n",
    "fig, axes = plt.subplots(3, n_col, figsize=(15,9),\n",
    "    )\n",
    "\n",
    "idx = np.where((df_ATE['rej']==1)&(df_STE['rej']==1)&(df_QTE['rej']==1)&(df_SQTE['rej']==1))[0]\n",
    "for ij in range(n_col):\n",
    "    j = idx[np.argsort(np.abs(df_SATE['tvalues_init'].values)[idx])[ij]]\n",
    "    axes[0,ij] = sns.histplot(pd.DataFrame({'x':resid[:,j], 'condition':np.where(A==1, 'treatment', 'control')}), \n",
    "        x = 'x', hue = 'condition', hue_order=['treatment', 'control'], bins=20,#bins=np.linspace(-10,10,50),\n",
    "        palette=colors, linewidth=0.1, edgecolor='k', ax=axes[0,ij])\n",
    "    axes[0,ij].set_title(gene_names[id_genes][j])\n",
    "\n",
    "i = 2\n",
    "idx = np.where((df_ATE['rej']==1)&(df_STE['rej']==1)&(df_QTE['rej']!=1)&(df_SQTE['rej']!=1))[0]\n",
    "for ij in range(n_col):\n",
    "    j = idx[np.argsort(np.abs(df_SATE['tvalues_init'].values)[idx])[ij]]\n",
    "    axes[i,ij] = sns.histplot(pd.DataFrame({'x':resid[:,j], 'condition':np.where(A==1, 'treatment', 'control')}), \n",
    "        x = 'x', hue = 'condition', hue_order=['treatment', 'control'], bins=20,\n",
    "        palette=colors, linewidth=0.1, edgecolor='k', ax=axes[i,ij])\n",
    "    axes[i,ij].set_title(gene_names[id_genes][j])\n",
    "\n",
    "i = 1\n",
    "idx = np.where((df_ATE['rej']!=1)&(df_STE['rej']!=1)&(df_QTE['rej']==1)&(df_SQTE['rej']==1))[0]\n",
    "for ij in range(n_col):\n",
    "    if ij>=len(idx):\n",
    "        fig.delaxes(axes[i,ij])\n",
    "        continue\n",
    "    j = idx[np.argsort(np.abs(df_QTE['tvalues_init'].values)[idx])[ij]]\n",
    "    axes[i,ij] = sns.histplot(pd.DataFrame({'x':resid[:,j], 'condition':np.where(A==1, 'treatment', 'control')}), \n",
    "        x = 'x', hue = 'condition', hue_order=['treatment', 'control'], bins=20,\n",
    "        palette=colors, linewidth=0.1, edgecolor='k', ax=axes[i,ij])\n",
    "    axes[i,ij].set_title(gene_names[id_genes][j])\n",
    "\n",
    "\n",
    "legend = axes[0,0].get_legend(); handles = legend.legendHandles\n",
    "labels = [t.get_text() for t in legend.get_texts()]\n",
    "for i in range(3):\n",
    "    for j in range(n_col):\n",
    "        try:\n",
    "            axes[i,j].get_legend().remove()\n",
    "        except:\n",
    "            pass\n",
    "        if i<2:\n",
    "            axes[i,j].set_xlabel('')\n",
    "        if i==2:\n",
    "            axes[i,j].set_xlabel('Residuals')\n",
    "        if j>0:\n",
    "            axes[i,j].set_ylabel('')\n",
    "\n",
    "\n",
    "legend = fig.legend(handles=handles, labels=labels, loc=9, ncol=10, title='Condition', frameon=False, fontsize=14)\n",
    "def legend_title_left(leg):\n",
    "    c = leg.get_children()[0]\n",
    "    title = c.get_children()[0]\n",
    "    hpack = c.get_children()[1]\n",
    "    c._children = [hpack]\n",
    "    hpack._children = [title] + hpack.get_children()\n",
    "legend_title_left(legend)\n",
    "\n",
    "axes[0,0].text(axes[0,0].get_xlim()[0]-0.4*(axes[0,0].get_xlim()[1]-axes[0,0].get_xlim()[0]), axes[0,0].get_ylim()[1], '(a)', fontsize=16, weight='bold')\n",
    "axes[1,0].text(axes[1,0].get_xlim()[0]-0.4*(axes[1,0].get_xlim()[1]-axes[1,0].get_xlim()[0]), axes[1,0].get_ylim()[1], '(b)', fontsize=16, weight='bold')\n",
    "axes[2,0].text(axes[2,0].get_xlim()[0]-0.4*(axes[2,0].get_xlim()[1]-axes[2,0].get_xlim()[0]), axes[2,0].get_ylim()[1], '(c)', fontsize=16, weight='bold')\n",
    "\n",
    "fig.tight_layout()\n",
    "fig.subplots_adjust(top=0.9)\n",
    "plt.savefig('figures/lupus_{}_residuals.pdf'.format(celltype), bbox_inches='tight', pad_inches=0, dpi=300)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "vitae",
   "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.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}