03_estimate_technical_overdispersion.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from scipy import sparse\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import pickle\n",
    "import copy\n",
    "\n",
    "from tools import compute_marginals, monitor_progress\n",
    "from nb_regression_R import extract_errors, extract_warnings, r_MLtheta"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load preprocessed negative control datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "code_folding": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1109/1701963246.py:3: DeprecationWarning: Please use `csr_matrix` from the `scipy.sparse` namespace, the `scipy.sparse.csr` namespace is deprecated.\n",
      "  datasets.append(pickle.load(f))\n",
      "/tmp/ipykernel_1109/1701963246.py:5: DeprecationWarning: Please use `csr_matrix` from the `scipy.sparse` namespace, the `scipy.sparse.csr` namespace is deprecated.\n",
      "  datasets.append(pickle.load(f))\n",
      "/tmp/ipykernel_1109/1701963246.py:7: DeprecationWarning: Please use `csr_matrix` from the `scipy.sparse` namespace, the `scipy.sparse.csr` namespace is deprecated.\n",
      "  datasets.append(pickle.load(f))\n"
     ]
    }
   ],
   "source": [
    "datasets = []\n",
    "with open('datasets/10x/sample1_preprocessed.pickle','rb') as f:\n",
    "    datasets.append(pickle.load(f))\n",
    "with open('datasets/indrop/GSM1599501_K562_pure_RNA.csv_preprocessed.pickle','rb') as f:\n",
    "    datasets.append(pickle.load(f))\n",
    "with open('datasets/microwellseq/GSM2906413_EmbryonicStemCell_dge.txt.gz_preprocessed.pickle','rb') as f:\n",
    "    datasets.append(pickle.load(f))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2000, 13025)  ---  2k Chromium control Svensson 2017 (10x v2) - sample 1\n",
      "(953, 25025)  ---  1k K562_pure_RNA Klein 2015 (inDrop)\n",
      "(9994, 15069)  ---  Han 2018 EmbryonicStemCell control (MicrowellSeq)\n"
     ]
    }
   ],
   "source": [
    "_=[print(d['counts'].shape,' --- ',d['label']) for d in datasets]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Use analyical solution for offsetmodel and then fit maximum likelihood $\\theta$ with 100 iterations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "def solve_offset_model(counts,depths):\n",
    "    '''computes analytical solution for beta0 per gene (Eq. 4 & 5)'''\n",
    "    total_sum = np.sum(depths)\n",
    "    gene_sum = counts.sum(axis=0)\n",
    "    beta0 = np.array(np.log(gene_sum/total_sum)).flatten()\n",
    "    \n",
    "    return beta0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "def fit_theta_offsetmodel(counts,max_iter,datalabel,fileprefix=''):\n",
    "    '''fits the offset model described in Eq.3, and then estimates\n",
    "       the overdisperson theta on the resulting predictions. \n",
    "       saves results to file in fit_results/.'''\n",
    "    \n",
    "    n_genes = counts.shape[1]        \n",
    "    savepath = 'fit_results/%sfit_theta_%s_maxiter%u.pickle' % (fileprefix,datalabel,max_iter)\n",
    "\n",
    "    depths = np.array(counts.sum(axis=1)).flatten()\n",
    "    gene_means = np.array(counts.mean(axis=0)).flatten()\n",
    "    #predict means for each cell/gene\n",
    "    beta0 = solve_offset_model(counts,depths)\n",
    "    mu = np.outer(depths,np.exp(beta0))\n",
    "\n",
    "    #for each gene, feed into R and fit theta\n",
    "    thetas = np.zeros((n_genes)) * np.nan\n",
    "    warning_msgs_R = n_genes * [['\"fitting error\"']]\n",
    "    errors = n_genes * [None]  \n",
    "    \n",
    "    for gene_id in range(counts.shape[1]):\n",
    "\n",
    "        gene_mu = mu[:,gene_id]\n",
    "        gene_counts = counts[:,gene_id].toarray()\n",
    "        \n",
    "        try:\n",
    "            theta,warning_msg_R = r_MLtheta(y=gene_counts,mu=gene_mu,max_iter=max_iter)\n",
    "            thetas[gene_id] = theta            \n",
    "            warning_msgs_R[gene_id] = warning_msg_R\n",
    "            \n",
    "        except Exception as error:            \n",
    "            errors[gene_id] = dict(gene_id=gene_id,error=error)            \n",
    "            \n",
    "        monitor_progress(gene_id,n_genes)\n",
    "\n",
    "            \n",
    "    #save\n",
    "    res = dict(thetas=np.array(thetas),\n",
    "               beta0=np.array(beta0),\n",
    "               gene_means=gene_means,\n",
    "               warning_msgs=extract_warnings(warning_msgs_R),\n",
    "               errors=extract_errors(errors),\n",
    "               max_iter=max_iter)\n",
    "    \n",
    "    pickle.dump(res,open(savepath, \"wb\"), protocol=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "## fit theta per gene in original data and save results as pickle\n",
    "## 25/35/80 min per datatset, respectively\n",
    "[fit_theta_offsetmodel(d['counts'],max_iter=100,datalabel=d['protocol']) for d in datasets]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "def simulate_control_data(dataset,theta,n_means_simulated,n_simulations,seed):\n",
    "    '''simulates a number of control datasets with same depths n as the provided\n",
    "    original dataset, and p's that span the range of p's in the original dataset.\n",
    "    Counts will be NB distributed with overdispersion parameter theta and mean n*p'''\n",
    "    \n",
    "    counts_orig = dataset['counts']\n",
    "    \n",
    "    #computing original ns and ps\n",
    "    ns_orig,ps_orig = compute_marginals(counts_orig)\n",
    "    ps_orig = ps_orig / np.sum(ps_orig)    \n",
    "\n",
    "    #compute range of ps\n",
    "    p_min = min(ps_orig)\n",
    "    p_max = max(ps_orig)\n",
    "    #compute ps to use \n",
    "    ps_sim = np.logspace(np.log10(p_min),np.log10(p_max),num=n_means_simulated) # limitsminam\n",
    "    #compute mean as n*p\n",
    "    mu_sim = np.outer(ns_orig,ps_sim)\n",
    "\n",
    "    #stimulate\n",
    "    counts_sim = []\n",
    "\n",
    "    np.random.seed(seed)    \n",
    "    for sim_id in range(n_simulations):\n",
    "        if theta == np.Inf:\n",
    "            counts = np.random.poisson(mu_sim)\n",
    "        else:\n",
    "            nb_p = theta / (theta + mu_sim)           \n",
    "            counts = np.random.negative_binomial(theta, nb_p)\n",
    "            \n",
    "        counts_sim.append(counts)\n",
    "            \n",
    "    counts_sim = np.array(counts_sim)\n",
    "    \n",
    "    return counts_sim   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "def fit_theta_for_simulated_dataset(dataset,thetas,max_iter,seed,n_means_simulated = 50,n_simulations = 1000):\n",
    "    '''for a given dataset, simulate control datasets with different thetas, and fit theta for each of them.\n",
    "       results will be in fit_results/control_simulations/'''\n",
    "\n",
    "    for theta in thetas:\n",
    "        counts_sim = simulate_control_data(dataset,theta=theta,n_means_simulated=n_means_simulated,n_simulations=n_simulations,seed=seed)\n",
    "\n",
    "        #fit\n",
    "        for sim_id in range(n_simulations):\n",
    "            counts = counts_sim[sim_id,:,:]\n",
    "            print('fitting simulation %u' % (sim_id))\n",
    "            datalabel = '%s_truetheta%s_simID%u' % (dataset['protocol'],theta,sim_id)\n",
    "\n",
    "            fit_theta_offsetmodel(sparse.csr_matrix(counts),max_iter=max_iter,datalabel=datalabel,fileprefix='control_simulations/')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "code_folding": [],
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# # simulate control datasets with different thetas, fit theta and save result to file\n",
    "# # 2h45min / 1h45min / 14h per dataset, respectively\n",
    "[fit_theta_for_simulated_dataset(d,thetas=[np.Inf, 1000,100,10],max_iter=100,seed=42) for d in datasets]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "def load_fits_simulated_dataset(dataset,true_theta,n_simulations,max_iter):\n",
    "    '''for a given dataset, load theta fits of control simulations'''\n",
    "\n",
    "      \n",
    "    thetas = []\n",
    "    means = []\n",
    "    warning_msgs = []\n",
    "    errors = []\n",
    "    \n",
    "    #load raw result files\n",
    "    for sim_id in range(n_simulations):\n",
    "        datalabel='%s_truetheta%s_simID%u' % (dataset['protocol'],true_theta,sim_id)\n",
    "        fitpath_sim = 'fit_results/control_simulations/fit_theta_%s_maxiter%u.pickle' % (datalabel,max_iter)            \n",
    "        fit_sim = pickle.load(open(fitpath_sim,'rb'))\n",
    "\n",
    "        #if any theta is estimated to be inf, set to fixed large value\n",
    "        inf_estimates = np.isinf(fit_sim['thetas'])\n",
    "        if np.any(inf_estimates):\n",
    "            inf_fill_value = 10**25\n",
    "            print(dataset['protocol'],'theta = ',true_theta,'simID = ',sim_id,'    %u infs detected, replaced by %.2E' % (sum(inf_estimates),inf_fill_value))\n",
    "            fit_sim['thetas'][inf_estimates] = inf_fill_value\n",
    "\n",
    "        #append results to list\n",
    "        thetas.append(fit_sim['thetas'])\n",
    "        means.append(fit_sim['gene_means'])\n",
    "        warning_msgs.append(fit_sim['warning_msgs'])\n",
    "        errors.append(fit_sim['errors'])\n",
    "\n",
    "    #re-organize to dict of arrays\n",
    "    thetas = np.array(thetas)\n",
    "    means = np.array(means)\n",
    "    warning_msgs = np.array(warning_msgs)\n",
    "    errors = np.array(errors)\n",
    "    \n",
    "    joined_fit = {}\n",
    "    joined_fit['errors'] = errors\n",
    "    joined_fit['thetas'] = thetas\n",
    "    joined_fit['gene_means'] = means\n",
    "         \n",
    "    return joined_fit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "def remove_diverged_thetas(means,thetas,errors,clipping_threshold):\n",
    "    '''identify and remove diverged genes.\n",
    "       Genes that \n",
    "           -have no counts observed\n",
    "           -had theta estimates with large values\n",
    "           -had theta estimate zero\n",
    "           -divergence errors\n",
    "       are set to np.nan.\n",
    "       Also returns means of theses genes'''\n",
    "    \n",
    "    #identify large-value divergence cases\n",
    "    thetas_large_idx = thetas > clipping_threshold\n",
    "    n_thetas_large = np.sum(thetas_large_idx)\n",
    "\n",
    "    #identify error divergence cases\n",
    "    inf_errortypes = ['Error in if (t0 < 0) { : missing value where TRUE/FALSE needed\\nCalls: <Anonymous> ... <Anonymous> -> withWarnings -> withCallingHandlers -> theta.ml\\n',\n",
    "                      'Error in while ((it <- it + 1) < limit && abs(del) > eps) { : \\n  missing value where TRUE/FALSE needed\\nCalls: <Anonymous> ... <Anonymous> -> withWarnings -> withCallingHandlers -> theta.ml\\n']    \n",
    "    inf_errors_idx = np.isin(errors,inf_errortypes)\n",
    "    n_inf_errors = np.sum(inf_errors_idx)\n",
    "\n",
    "    #identify zero-mean or zero-theta cases\n",
    "    theta_zero_idx = thetas == 0\n",
    "    means_zero_idx = means == 0\n",
    "\n",
    "    #combine removal criteria\n",
    "    remove_idx = np.where(inf_errors_idx | thetas_large_idx | theta_zero_idx | means_zero_idx)\n",
    "\n",
    "    #extract means of removed genes\n",
    "    means_removed_nonzero = means[(inf_errors_idx | thetas_large_idx | theta_zero_idx) & ~means_zero_idx]\n",
    "\n",
    "    #set removed genes to nan\n",
    "    thetas[remove_idx] = np.nan\n",
    "    means[remove_idx] = np.nan\n",
    "    \n",
    "    return means,thetas, means_removed_nonzero"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "letter_position=(-0.12,1.45)\n",
    "legend_position=(0.6,-0.01)\n",
    "dotsize=3\n",
    "title_fontsize = 22\n",
    "title_fontweight = \"bold\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "def plot_theta_estimates_orig_vs_simulated(ax,hist_ax,dataset,true_thetas,max_iter=100,n_simulations=1000,markersize=dotsize,clipping_threshold = 10**5,log10jittersize=0.5):    \n",
    "    '''For a given dataset, plots how well theta estimates agree between estimates from original data and estimates from control data with known theta.'''\n",
    "\n",
    "    ymin,ymax = [10**-4.5,10**5]\n",
    "    xmin,xmax = [10**-4,10**3]\n",
    "    \n",
    "    #load fit of original data\n",
    "    datalabel=dataset['protocol']\n",
    "    fileprefix=''    \n",
    "    fitpath_orig = 'fit_results/%sfit_theta_%s_maxiter%u.pickle' % (fileprefix,datalabel,max_iter)    \n",
    "    fit_orig = pickle.load(open(fitpath_orig,'rb'))    \n",
    "    #unpack\n",
    "    means_orig = copy.deepcopy(fit_orig['gene_means'] )\n",
    "    thetas_orig = fit_orig['thetas']\n",
    "    errors_orig = fit_orig['errors'] \n",
    "\n",
    "    #set means and thetas of diverged thetas to nan and recover the  removed mean values\n",
    "    means_orig, thetas_orig, means_orig_diverged = remove_diverged_thetas(means_orig,thetas_orig,errors_orig,clipping_threshold)\n",
    "    \n",
    "    #plot theta estimates for real data\n",
    "    ax.scatter(means_orig,thetas_orig,s=markersize,color='k',  rasterized=True)\n",
    "    \n",
    "    ### compute histogram over all gene means and means of diverged genes\n",
    "    # setup\n",
    "    xmin_hist = 10**-3.6\n",
    "    xmax_hist = xmax\n",
    "    ymin_hist = clipping_threshold*5\n",
    "    ymax_hist = ymax\n",
    "    \n",
    "    #compute bins\n",
    "    bins_orig = np.logspace(np.log10(xmin_hist),np.log10(xmax_hist),100)\n",
    "    binwidths_orig = bins_orig[1:] - bins_orig[:-1]\n",
    "    bincenters_orig = (bins_orig[1:] + bins_orig[:-1])/2\n",
    "    left_binedges_orig = bins_orig[:-1]\n",
    "    \n",
    "    # compute histograms\n",
    "    hist_meansOrig_diverged,_ = np.histogram(means_orig_diverged,bins=bins_orig)\n",
    "    hist_meansOrig_all,_ = np.histogram(fit_orig['gene_means'],bins=bins_orig)\n",
    "    # normalize diverged cases by all cases\n",
    "    hist_meansOrig_diverged_normalized = hist_meansOrig_diverged/hist_meansOrig_all\n",
    "\n",
    "    \n",
    "    ### plot percentile regions for theta estimates on simulated data\n",
    "    for true_theta in true_thetas:\n",
    "        if np.isinf(true_theta):\n",
    "            theta_label = '\\infty'\n",
    "        else:\n",
    "            theta_label=true_theta\n",
    "        \n",
    "        #load & unpack fits\n",
    "        fits_sim = load_fits_simulated_dataset(dataset,true_theta,n_simulations,max_iter)        \n",
    "        means_sim = copy.deepcopy(fits_sim['gene_means'])\n",
    "        thetas_sim = fits_sim['thetas']\n",
    "        errors_sim = fits_sim['errors'] \n",
    "        \n",
    "        #handle diverged cases as above\n",
    "        means_sim, thetas_sim, means_sim_diverged = remove_diverged_thetas(means_sim,thetas_sim,errors_sim,clipping_threshold)\n",
    "        #get means and percentiles across simulation runs, ignoring diverged cases\n",
    "        means_mean = np.nanmean(means_sim,axis=0)\n",
    "        thetas_p5 = np.nanpercentile(thetas_sim,5,axis=0)\n",
    "        thetas_p95 = np.nanpercentile(thetas_sim,95,axis=0)\n",
    "        \n",
    "        #plot percentile region\n",
    "        fill = ax.fill_between(means_mean,thetas_p5,thetas_p95,alpha=0.7,linewidth=0,label=r'$\\theta=%s$'%theta_label)\n",
    "        \n",
    "        #get histogram of diverged cases and plot as line\n",
    "        bins_sim = np.logspace(np.log10(xmin_hist),np.log10(xmax_hist),15)\n",
    "        bincenters_sim = (bins_sim[1:] + bins_sim[:-1])/2\n",
    "        hist_meansSim_diverged,_ = np.histogram(means_sim_diverged,bins=bins_sim)\n",
    "        hist_meansSim_all,_ = np.histogram(fits_sim['gene_means'].flatten(),bins=bins_sim,)\n",
    "        \n",
    "        hist_meansSim_diverged_normalized = hist_meansSim_diverged/hist_meansSim_all\n",
    "        hist_ax.plot(bincenters_sim,hist_meansSim_diverged_normalized*100,linewidth=4,alpha=0.7,clip_on=False)\n",
    "\n",
    "    # plot\n",
    "    hist_ax.bar(left_binedges_orig,hist_meansOrig_diverged_normalized*100,binwidths_orig,color='k',align='edge')\n",
    "\n",
    "    hist_ax.set_xlim([xmin_hist,xmax_hist])\n",
    "    hist_ax.set_xscale('log')\n",
    "    hist_ax.set_yticks([0,100])\n",
    "    hist_ax.set_ylim([0,100])\n",
    "\n",
    "    hist_ax.set_xticks([0.001,0.1,10,1000])\n",
    "    hist_ax.set_xticklabels([])\n",
    "    hist_ax.set_title(dataset['protocol'])\n",
    "\n",
    "    sns.despine(ax=hist_ax)   \n",
    "    hist_ax.tick_params(axis='x',          \n",
    "                        which='minor',      \n",
    "                        bottom=False,      \n",
    "                        top=False,         \n",
    "                        labelbottom=False)\n",
    "    \n",
    "    ax.set_xscale('log')\n",
    "    ax.set_yscale('log')\n",
    "    ax.set_ylim([ymin,ymax])\n",
    "    ax.set_xlim([xmin,xmax])\n",
    "    ax.set_xlabel('expression mean')\n",
    "    ax.set_xticks([0.001,0.1,10,1000])\n",
    "    sns.despine(ax=ax)\n",
    "    \n",
    "    plt.tight_layout(h_pad=0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Figure S1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "code_folding": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1109/2414153900.py:40: RuntimeWarning: invalid value encountered in true_divide\n",
      "  hist_meansOrig_diverged_normalized = hist_meansOrig_diverged/hist_meansOrig_all\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10X theta =  inf simID =  370     1 infs detected, replaced by 1.00E+25\n",
      "10X theta =  inf simID =  401     1 infs detected, replaced by 1.00E+25\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1109/2414153900.py:59: RuntimeWarning: Mean of empty slice\n",
      "  means_mean = np.nanmean(means_sim,axis=0)\n",
      "/usr/local/lib/python3.8/dist-packages/numpy/lib/nanfunctions.py:1395: RuntimeWarning: All-NaN slice encountered\n",
      "  result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n",
      "/tmp/ipykernel_1109/2414153900.py:40: RuntimeWarning: invalid value encountered in true_divide\n",
      "  hist_meansOrig_diverged_normalized = hist_meansOrig_diverged/hist_meansOrig_all\n",
      "/tmp/ipykernel_1109/2414153900.py:59: RuntimeWarning: Mean of empty slice\n",
      "  means_mean = np.nanmean(means_sim,axis=0)\n",
      "/usr/local/lib/python3.8/dist-packages/numpy/lib/nanfunctions.py:1395: RuntimeWarning: All-NaN slice encountered\n",
      "  result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n",
      "/tmp/ipykernel_1109/2414153900.py:72: RuntimeWarning: invalid value encountered in true_divide\n",
      "  hist_meansSim_diverged_normalized = hist_meansSim_diverged/hist_meansSim_all\n",
      "/tmp/ipykernel_1109/2414153900.py:72: RuntimeWarning: invalid value encountered in true_divide\n",
      "  hist_meansSim_diverged_normalized = hist_meansSim_diverged/hist_meansSim_all\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inDrop theta =  100 simID =  855     1 infs detected, replaced by 1.00E+25\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1109/2414153900.py:72: RuntimeWarning: invalid value encountered in true_divide\n",
      "  hist_meansSim_diverged_normalized = hist_meansSim_diverged/hist_meansSim_all\n",
      "/tmp/ipykernel_1109/2414153900.py:72: RuntimeWarning: invalid value encountered in true_divide\n",
      "  hist_meansSim_diverged_normalized = hist_meansSim_diverged/hist_meansSim_all\n",
      "/tmp/ipykernel_1109/2414153900.py:40: RuntimeWarning: invalid value encountered in true_divide\n",
      "  hist_meansOrig_diverged_normalized = hist_meansOrig_diverged/hist_meansOrig_all\n",
      "/tmp/ipykernel_1109/2414153900.py:59: RuntimeWarning: Mean of empty slice\n",
      "  means_mean = np.nanmean(means_sim,axis=0)\n",
      "/usr/local/lib/python3.8/dist-packages/numpy/lib/nanfunctions.py:1395: RuntimeWarning: All-NaN slice encountered\n",
      "  result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n",
      "/tmp/ipykernel_1109/2414153900.py:72: RuntimeWarning: invalid value encountered in true_divide\n",
      "  hist_meansSim_diverged_normalized = hist_meansSim_diverged/hist_meansSim_all\n",
      "/tmp/ipykernel_1109/2414153900.py:59: RuntimeWarning: Mean of empty slice\n",
      "  means_mean = np.nanmean(means_sim,axis=0)\n",
      "/usr/local/lib/python3.8/dist-packages/numpy/lib/nanfunctions.py:1395: RuntimeWarning: All-NaN slice encountered\n",
      "  result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n",
      "/tmp/ipykernel_1109/2414153900.py:72: RuntimeWarning: invalid value encountered in true_divide\n",
      "  hist_meansSim_diverged_normalized = hist_meansSim_diverged/hist_meansSim_all\n",
      "/tmp/ipykernel_1109/2414153900.py:59: RuntimeWarning: Mean of empty slice\n",
      "  means_mean = np.nanmean(means_sim,axis=0)\n",
      "/usr/local/lib/python3.8/dist-packages/numpy/lib/nanfunctions.py:1395: RuntimeWarning: All-NaN slice encountered\n",
      "  result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n",
      "/tmp/ipykernel_1109/2414153900.py:72: RuntimeWarning: invalid value encountered in true_divide\n",
      "  hist_meansSim_diverged_normalized = hist_meansSim_diverged/hist_meansSim_all\n",
      "/tmp/ipykernel_1109/2414153900.py:72: RuntimeWarning: invalid value encountered in true_divide\n",
      "  hist_meansSim_diverged_normalized = hist_meansSim_diverged/hist_meansSim_all\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x432 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "with sns.plotting_context('talk'):\n",
    "    \n",
    "    fig,axes = plt.subplots(2,3,figsize=(18,6),sharex=True,sharey=False, gridspec_kw={'height_ratios': [1, 4]})\n",
    "    letters = ['a','b','c']\n",
    "    axes_main = axes[1,:]\n",
    "    axes_hist = axes[0,:]\n",
    "    \n",
    "    for i,(ax,hist_ax,letter) in enumerate(zip(axes_main.flatten(),axes_hist.flatten(),letters)):\n",
    "        \n",
    "        plot_theta_estimates_orig_vs_simulated(ax,hist_ax,datasets[i],true_thetas=[np.Inf,1000,100,10])\n",
    "        hist_ax.text(*letter_position,letter,transform=hist_ax.transAxes,fontsize=title_fontsize,fontweight=title_fontweight)\n",
    "        \n",
    "        if i == 0:\n",
    "            ax.legend(frameon=False,loc=legend_position)\n",
    "            hist_ax.set_ylabel('Diverged\\nestimates (%)',labelpad=7.5)\n",
    "            ax.set_ylabel('Converged\\nestimates',labelpad=0)\n",
    "            \n",
    "    plt.savefig('figures/FigS1.pdf', dpi=300, format=None)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext watermark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Last updated: 2021-07-31T15:49:00.746018+02:00\n",
      "\n",
      "Python implementation: CPython\n",
      "Python version       : 3.8.0\n",
      "IPython version      : 7.21.0\n",
      "\n",
      "Compiler    : GCC 8.3.0\n",
      "OS          : Linux\n",
      "Release     : 3.10.0-957.el7.x86_64\n",
      "Machine     : x86_64\n",
      "Processor   : x86_64\n",
      "CPU cores   : 40\n",
      "Architecture: 64bit\n",
      "\n"
     ]
    }
   ],
   "source": [
    "watermark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "scipy     : 1.6.0\n",
      "seaborn   : 0.11.1\n",
      "numpy     : 1.20.1\n",
      "matplotlib: 3.3.3\n",
      "\n"
     ]
    }
   ],
   "source": [
    "watermark --iversions"
   ]
  },
  {
   "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.8.10"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}