Generate_n_analyze_exp.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Maximum likelihood estimate on cancer stem cell proliferation and differentiation rate\n",
    "\n",
    "\n",
    "In this notebook, I implemented the two models derived in the main text. The goal is to infer model parameters (e.g. proliferation and differentiation rate of cancer stem cells/tumor initiating cells (TICs) and the division rate of differentiated cells (DC)), depending on the model under consideration. Below is a brief description and a schematic of the two models studied.\n",
    "\n",
    "\n",
    "### Model 1\n",
    "\n",
    "To construct the models, we'll need to specify a few things: \n",
    "\n",
    " * *model_type = I* \n",
    " * *model_para = {pvec, N0, T, Nexp}*: \n",
    "    * *pvec* : $\\mathbf{p}=(p_0, p_1,p_2)$, where $p_0$ is the probability of death, $p_1$ of self-renewal, and $p_2$ is of symmetric division, all of TICs. \n",
    "    * *N1* : Number of TICs at $t=0$\n",
    "    * *T* : Generations. Simulations runs from  $t=0,1,\\cdots, T$\n",
    "    * *Nexp* : Number of observations at each time point $t$\n",
    " \n",
    "In this simulation class, at the end of each cell cycle, DCs die with probability 1 without producing any progenies. TIC, on the other hand, either dies with probability $p_0$, or self-renews to produce tww TICs with probability $p_1$, or differentiates into two DCs with probability $p_2$.\n",
    "\n",
    "\n",
    "### Model 2\n",
    " * *model_type = II* \n",
    " * *model_para = {pvec, N0, T, Nexp}*: \n",
    "    * *pvec* : $\\mathbf{p}=(p, \\lambda, q)$, where $1-p$ is the probability of death, $p(1-\\lambda)$ of self-renewal, and $p\\lambda$ is of asymmetric division, all of TICs. $q$ is the survival probability of DCs.\n",
    "    * *N1* : Number of TICs at $t=0$\n",
    "    * *T* : Geenerations. Simulations runs from  $t=0,1,\\cdots, T$\n",
    "    * *Nexp* : Number of observations at each time point $t$\n",
    "\n",
    "\n",
    "\n",
    "<img src=\"files/model-schematic-eps-converted-to.png\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data to do MLE on:\n",
    "\n",
    "Cconsider an experiment consisting of $n$ measurements on the TIC fraction on different cell cultures labeled by $k=1,2,\\cdots, n$. Culture $k$ started out with $N_k$ TICs and nothing else. It is then taken out to measure its TIC fraction at time $t_k$ denoted as $\\Delta_1(t_k, N_k)$ (see Figure below). Note that we assume $t_1 < t_2 <\\cdots < t_n$. The asymptotic normality of the relative frequency implies that as long as the initial TIC counts are large in the sense that $\\min (N_0,\\cdots, N_n)\\gg 1$ and the cell number variance is bounded, $\\sigma_i^2(t)< \\infty$, the asymptotic likelihood of $\\mathcal{D} = \\{\\Delta_1(t_k, N_k)\\}_{k=1}^n$, $L_n(\\mathcal{D}|p_1,p_2)$, is given by\n",
    "\n",
    "\n",
    "\\begin{eqnarray}\\label{eq:exp_lhd}\n",
    "L_n(\\mathcal{D}|p_1,p_2) &=& -\\frac{n}{2}\\log 2\\pi -\\frac{1}{2}\\sum_{k=1}^n \\log S^2(t_k; N_k)-\\frac{1}{2}\\sum_{k=1}^n[\\Delta_1(t_k, N_k)-p_1(t_k)]^2/S^2(t_k; N_k),\n",
    "\\end{eqnarray}\n",
    "where $p(t_k) = m_{11}(t_k)/M(t_k)$, $M(t_k) = m_{11}(t_k) + m_{12}(t_k)$. \n",
    "\n",
    "The expression $S_1^2$ is given by\n",
    "\\begin{eqnarray}\n",
    "S_1^2(t_k; N_k) &=&\\frac{1}{N_k M^2(t_k)}\\{\\sigma_1^2(t_k)[1-p_1(t_k)]^2+\\sigma_2^2(t_k)p_1^2(t_k) - 2\\Sigma_{12}(t_k)p_1(t_k)[1-p_1(t_k)]\\},\n",
    "\\end{eqnarray}\n",
    "where $\\sigma_i^2(t_k) = b^1_{ii}(t_k)+ m_{ii}(t_k)-m_{ii}^2(t_k)$ and ${\\Sigma}_{12}(t_k) = b^1_{12}(t) - m_{11}(t_k)m_{12}(t_k)$.\n",
    "\n",
    "The quantities are explicitly derived in my note.\n",
    "\n",
    "<img src=\"files/exp_protocol-eps-converted-to.png\" width=800>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "#import pandas as pd\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "import sys\n",
    "import pickle\n",
    "import os\n",
    "\n",
    "\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "sns.set(style=\"white\", font_scale = 2)\n",
    "dir_name='./'\n",
    "class bayesian_TIC_exp:\n",
    "    \n",
    "    def __init__(self, model_type = 'I', parameters = {'pvec': [0.0, 0.5, 0.5], 'N1': 100, 'T': 20, 'Nexp': 10}):\n",
    "        \n",
    "        # Total number of generations\n",
    "        self.T = parameters['T'] \n",
    "        \n",
    "        # Number of TICs at t = 0\n",
    "        self.N1 = parameters['N1']\n",
    "        \n",
    "        # Growth parameter\n",
    "        self.p = parameters['pvec']\n",
    "        self.type = model_type\n",
    "        \n",
    "        \n",
    "        # Number of observations\n",
    "        self.Nexp = parameters['Nexp']\n",
    "        \n",
    "        \n",
    "        # Initialization\n",
    "        self.renew_exp()\n",
    "        self.delta = []\n",
    "        self.S2all = []\n",
    "        self.pkall = []\n",
    "        self.Nk = []\n",
    "        self.Tk = []\n",
    "\n",
    "    \n",
    "        \n",
    "        \n",
    "        self.simulate()\n",
    "        self.analyze_exp(True)\n",
    "        #self.save_exp()\n",
    "\n",
    "        \n",
    "\n",
    "\n",
    "    def simulate(self):\n",
    "        \n",
    "        for i in range(self.Nexp):\n",
    "            self.renew_exp()\n",
    "            \n",
    "            self.T_exp = self.T*(i+1)\n",
    "            self.Tk = self.Tk + [self.T_exp]\n",
    "            self.Nk = self.Nk + [self.pop[0]]\n",
    "            \n",
    "            for j in range(self.T_exp):\n",
    "                self.grow_n_measure()\n",
    "            \n",
    "            \n",
    "            \n",
    "            self.delta = self.delta + [self.n1[-1]]\n",
    "        \n",
    "            \n",
    "            \n",
    "    def renew_exp(self):\n",
    "        \n",
    "        # Initial population [TICs, DCs]\n",
    "       \n",
    "        self.pop = [np.random.poisson(self.N1), 0]\n",
    "        \n",
    "        # Initial TIC fraction\n",
    "        self.n1 = [1.0]\n",
    "        self.n2 = [0.0]\n",
    "        \n",
    "        # Initial TIC numer\n",
    "        self.z1 = [self.N1]\n",
    "        self.z2 = [0]\n",
    "        \n",
    "        \n",
    "        \n",
    "        \n",
    "    def grow_n_measure(self):\n",
    "        \n",
    "        \n",
    "        if self.type == 'I':\n",
    "            cycle = np.random.rand(self.pop[0])\n",
    "            delta_pop = [(cycle < self.p[0]).sum(), ((cycle >= self.p[0]) & (cycle < self.p[0] + self.p[1])).sum(), ((cycle >= self.p[0] + self.p[1]) & (cycle < 1.0)).sum()]\n",
    "            self.pop[0] = self.pop[0] - (delta_pop[0] + delta_pop[2]) + delta_pop[1]\n",
    "            self.pop[1] = 2.0*delta_pop[2]\n",
    "            self.z1.append(self.pop[0])\n",
    "            self.z2.append(self.pop[1])\n",
    "            self.n1.append(float(self.pop[0]/sum(self.pop)))\n",
    "            self.n2.append(float(self.pop[1]/sum(self.pop)))\n",
    "            self.pop[1] = 0\n",
    "            \n",
    "            \n",
    "        elif self.type == 'II':\n",
    "            cycle = np.random.rand(self.pop[0])\n",
    "            cycle1 = np.random.rand(self.pop[1])\n",
    "            p0 = 1.0 - self.p[0] # TIC dies\n",
    "            p1 = self.p[0]*(1.0 -self.p[1]) # TIC self-renews\n",
    "            delta_pop = [(cycle < p0).sum(), ((cycle >= p0) & (cycle < p0 + p1)).sum(), ((cycle >= p0 + p1) & (cycle < 1.0)).sum()]\n",
    "            self.pop[0] = self.pop[0] - delta_pop[0] + delta_pop[1]\n",
    "            \n",
    "            delta_pop1 = [(cycle1 < 1.0-self.p[2]).sum(), ((cycle1 >= 1.0-self.p[2]) & (cycle1 < 1.0)).sum() ]\n",
    "            self.pop[1] = self.pop[1] + delta_pop[2]  + delta_pop1[1] - delta_pop1[0]\n",
    "            self.z1.append(self.pop[0])\n",
    "            self.z2.append(self.pop[1])\n",
    "            self.n1.append(float(self.pop[0]/sum(self.pop)))\n",
    "            self.n2.append(float(self.pop[1]/sum(self.pop)))\n",
    "            \n",
    "                       \n",
    "            \n",
    "\n",
    "    def analyze_exp(self, c = False):\n",
    "\n",
    "        if c == True:\n",
    "            if self.type == 'I':\n",
    "                n1, n2= (20, 20)\n",
    "                p1 = np.linspace(0.1, 0.8, n1) # p1: renewal prob\n",
    "                p2 = np.linspace(0.1, 0.8, n2) # p2: symmetric division\n",
    "                p1v, p2v = np.meshgrid(p1, p2)\n",
    "                lhd = np.zeros([n1,n2])\n",
    "\n",
    "\n",
    "                for ix in range(n1):\n",
    "                    for iy in range(n2):\n",
    "                        self.q1 = p1[ix]\n",
    "                        self.q2 = p2[iy]\n",
    "                        self.compute_statistics_theory()\n",
    "                        \n",
    "                        lhd[ix,iy] = self.log_lhd\n",
    "                self.lhd_all = lhd\n",
    "\n",
    "\n",
    "                ind = np.unravel_index(np.argmax(lhd, axis=None), lhd.shape)\n",
    "                xmax = [p1[ind[0]]]\n",
    "                ymax = [p2[ind[1]]]\n",
    "                st =  '(' + f\"{p1[ind[0]]:.2f}\" +', ' + f\"{p2[ind[1]]:.2f}\" + ')'\n",
    "\n",
    "                \n",
    "                # set up figure\n",
    "                fig, ax = plt.subplots(figsize = (8,6))\n",
    "                fs = 18 # font size\n",
    "                fs_s = 12 # small text font size\n",
    "                ms = 5 # marker size\n",
    "                ms_s = 2\n",
    "                lw = 3 # line width size\n",
    "\n",
    "                plt.pcolormesh(p1v, p2v, np.transpose(lhd))\n",
    "                plt.colorbar() #need a colorbar to show the intensity scale\n",
    "                plt.scatter(xmax, ymax, s=100, facecolors='none', edgecolors='k')\n",
    "                plt.scatter([self.p[1]], [self.p[2]], marker = '^', s=100, facecolors='none', edgecolors='b')\n",
    "                plt.text(0.2, 0.2, r'$\\theta_0 =($' + str(self.p[1]) + ', ' + f\"{self.p[2]:.2f}\" + r'$)$', color = 'b', fontsize=20)\n",
    "                plt.text(0.4, 0.3, r'$\\hat{\\theta}_{MLE} =$' + st, color = 'k', fontsize=20)\n",
    "                plt.title(\"MLE\")\n",
    "                plt.xlabel(r\"self-renew, $p_1$\")\n",
    "                plt.ylabel(r\"differentiate, $p_2$\")\n",
    "                plt.show() #boom\n",
    "                \n",
    "                file_str = 'EXP_' + self.type + '_T'+ str(self.T) + '_Nexp' + str(self.Nexp) + '_N0' + str(self.N1) + '_pvec' + str(self.p[0])  + '_' + str(self.p[1])+ '_' + str(self.p[2])\n",
    "                title_str = 'MLE_' + file_str\n",
    "                fig.savefig(title_str + '.pdf', bbox_inches='tight')\n",
    "                \n",
    "            \n",
    "            elif self.type == 'II':\n",
    "                n1, n2= (20, 20)\n",
    "                p1 = np.linspace(0.5, 0.75, n1) # p: TIC survival\n",
    "                p2 = np.linspace(0.5, 0.7, n2) # lambda: TIC asym differentiate\n",
    "                p1v, p2v = np.meshgrid(p1, p2)\n",
    "                lhd = np.zeros([n1,n2])\n",
    "\n",
    "    \n",
    "                for ix in range(n1):\n",
    "                    for iy in range(n2):\n",
    "                        self.q1 = p1[ix]\n",
    "                        self.q2 = p2[iy]\n",
    "                        self.q3 = self.p[2]\n",
    "                        self.compute_statistics_theory()\n",
    "                            \n",
    "                        lhd[ix,iy] = self.log_lhd\n",
    "                self.lhd_all = lhd\n",
    "                    \n",
    "                ind = np.unravel_index(np.argmax(lhd, axis=None), lhd.shape)\n",
    "                xmax = [p1[ind[0]]]\n",
    "                ymax = [p2[ind[1]]]\n",
    "                st =  '(' + f\"{p1[ind[0]]:.3f}\" +', ' + f\"{p2[ind[1]]:.3f}\" + ')'\n",
    "                \n",
    "\n",
    "               # set up figure\n",
    "                fig, ax = plt.subplots(figsize = (8,6))\n",
    "                fs = 18 # font size\n",
    "                fs_s = 12 # small text font size\n",
    "                ms = 5 # marker size\n",
    "                ms_s = 2\n",
    "                lw = 3 # line width size\n",
    "\n",
    "                plt.pcolormesh(p1v, p2v, np.transpose(lhd))\n",
    "                plt.colorbar() #need a colorbar to show the intensity scale\n",
    "                plt.scatter(xmax, ymax, s=100, facecolors='none', edgecolors='k')\n",
    "                plt.scatter([self.p[0]], [self.p[1]], marker = '^', s=100, facecolors='none', edgecolors='b')\n",
    "                plt.text(0.6, 0.62, r'$\\theta_0 =($' + f\"{self.p[0]:.2f}\" + ', ' + f\"{self.p[1]:.2f}\" + r'$)$', color = 'b', fontsize=20)\n",
    "                plt.text(0.6, 0.58, r'$\\hat{\\theta}_{MLE} =$' + st, color = 'k', fontsize=20)\n",
    "                plt.title(r'MLE, $q = $' + str(self.p[2]))\n",
    "                plt.xlabel(r\"survive, $p$\")\n",
    "                plt.ylabel(r\"differentiate, $\\lambda$\")\n",
    "                plt.show() #boom\n",
    "                \n",
    "                file_str = 'EXP_' + self.type + '_T'+ str(self.T) + '_Nexp' + str(self.Nexp) + '_N0' + str(self.N1) + '_pvec' + str(self.p[0])  + '_' + str(self.p[1])+ '_' + str(self.p[2])\n",
    "                title_str = 'MLE_' + file_str\n",
    "                fig.savefig(title_str + '.pdf', bbox_inches='tight')\n",
    "\n",
    "      \n",
    "\n",
    "\n",
    "    def compute_statistics_theory(self):\n",
    "\n",
    "        # this function computes the followings:\n",
    "        #  s1 : number variance of z1\n",
    "        #  s2 : number variance of z2\n",
    "        #  cov: covariance Cov(z1, z2)\n",
    "        #  pk1: mean fraction of z1\n",
    "        #  pk2: mean fraction of z2\n",
    "        #  S : variance of n1\n",
    "\n",
    "       \n",
    "        s1 = []\n",
    "        s2 = []\n",
    "        cov = []\n",
    "        pk1 = []\n",
    "        pk2 = []\n",
    "        S = []\n",
    "        M = []\n",
    "\n",
    "\n",
    "        if self.type == 'I':\n",
    "            x = 2.0*self.q1 # 2 times the self-renewal prob\n",
    "            y = 2.0*self.q2 # 2 times the symmetric division prob\n",
    "            \n",
    "            for it in self.Tk:\n",
    "                index = self.Tk.index(it)\n",
    "                if x != 1.0:\n",
    "                    s1 = s1 + [x**it *(x**it - 1.0)*2.0*(1-x/2.0)/(x-1.0)]\n",
    "                    s2 = s2 + [(y**2)*(x**(it-1))*(1.0-(x**(it)))/ (1.0 -x) + y*(x**(it-1))]\n",
    "                    cov = cov + [y*(x**it)*((1.0 - (x**(it-1)))/(1.0 -x)-(x**(it-1)))]\n",
    "                else:\n",
    "                    s1 = s1 + [x**it *it*2.0*(1.0-x/2.0)]\n",
    "                    s2 = s2 + [(y**2)*(x**(it-1))*(it) + y*(x**(it-1))]\n",
    "                    cov = cov + [y*(x**it)*(it-1-(x**(it-1)))]\n",
    "\n",
    "                \n",
    "                pk1 = pk1 + [x / (x+y)]\n",
    "                pk2 = pk2 + [1.0-pk1[-1]]\n",
    "                M = M + [(x**it) + y*(x**(it-1))]\n",
    "                S  = S  + [ (s1[-1]*(1.0 - pk1[-1])**2 + s2[-1]*(pk1[-1]**2) - 2.0*cov[-1]*pk1[-1]*(1.0 - pk1[-1]))/self.Nk[index]/M[-1]/M[-1]]\n",
    "            self.s1 = s1\n",
    "            self.s2 = s2\n",
    "            self.cov = cov\n",
    "            self.pk1 = pk1\n",
    "            self.pk2 = pk2\n",
    "            self.S = S\n",
    "            \n",
    "            \n",
    "        elif self.type == 'II':\n",
    "            x = self.q1 # p\n",
    "            y = self.q2 # lambda\n",
    "            z = self.q3 # q\n",
    "\n",
    "            for it in self.Tk:\n",
    "                index = self.Tk.index(it)\n",
    "                s1  = s1  + [(x**(it))*(2.0-y)**(it-1)*((2.0-y)*(1.0-(x*(2.0-y))**it) + 2.0*it*(1.0-y))]\n",
    "                pk1 = pk1 + [(x*(2.0-y))**(it)*(2*z-x*(2-y)) /(2.0*(z-x)*(x*(2-y))**it + x*y*(2*z)**it)]\n",
    "                b22t = 0.0\n",
    "                \n",
    "                for iit in range(1, it):\n",
    "                    if 2*z == x*(2.0-y):\n",
    "                        m12 = x*y*iit*(x*(2.0-y))**(iit-1)\n",
    "                    else:\n",
    "                        m12 = x*y*((2*z)**iit -(x*(2.0 - y))**iit)/(2*z - x*(2.0-y))\n",
    "\n",
    "                    if 2*z == 1.0:\n",
    "                        b22t += (m12*m12*2*x*(1.0-y) + (x*y*(2*z)**iit)*(2*m12+ iit))*(x*(2.0-y))**(it-1-iit)\n",
    "                    else:\n",
    "                        b22t += (m12*m12*2*x*(1.0-y) + (x*y*(2*z)**iit)*(2*m12+ (1.0-(2*z)**iit)/(1.0-2*z)))*(x*(2.0-y))**(it-1-iit)\n",
    "                \n",
    "                s2 = s2 + [b22t + (2*z)**it - (2*z)**(2*it)]\n",
    "\n",
    "                \n",
    "                if 2*z == x*(2.0-y) and 2*z == 1.0:\n",
    "                    at = 1.0 + it-1.0\n",
    "                elif 2*z == x*(2.0-y) and 2*z != 1.0:\n",
    "                    at = 1.0 + 2*z*(1.0-(2*z)**(it-1))/ (1-2*z)\n",
    "                elif 2*z == 1.0 and x*(2-y) != 1.0:\n",
    "                    at = 1.0 + (2*z*(2*z-x*y)*(it-1) - 2*x*(1.0-y)*(x*(2.0-y))*(1.0 - (x*(2.0-y))**(it-1))/(1.0-x*(2-y))) /(2*z - x*(2.0-y))\n",
    "                elif 2*z != 1.0 and x*(2-y) == 1.0:\n",
    "                    at = 1.0 + (2*z*(2*z-x*y)*(1.0-(2*z)**(it-1))/(1.0-2.0*z) - 2*x*(1.0-y)*(x*(2.0-y))*(it-1)) /(2*z - x*(2-y))\n",
    "                else:\n",
    "                    at = 1.0 + (2*z*(2*z-x*y)*(1.0-(2*z)**(it-1))/(1.0-2.0*z) - 2*x*(1.0-y)*(x*(2.0-y))*(1.0 - (x*(2.0-y))**(it-1))/(1.0-x*(2.0-y))) /(2*z - x*(2-y))\n",
    "\n",
    "                \n",
    "                if 2*z == x*(2.0-y):\n",
    "                    m12t = x*y*it*(x*(2.0-y))**(it-1)\n",
    "                else:\n",
    "                    m12t = x*y*((2*z)**it -(x*(2.0 - y))**it)/(2*z - x*(2.0-y))\n",
    "                \n",
    "                cov = cov + [at*y*(x**it)*(2.0 -y)**(it-1)-((x*(2.0-y))**it)*m12t]\n",
    "                pk2 = pk2 + [1.0-pk1[-1]]\n",
    "                M = M + [(x**it)*(2.0-y)**it + m12t]\n",
    "                S  = S  + [(s1[-1]*(1.0 - pk1[-1])**2 + s2[-1]*(pk1[-1]**2) - 2.0*cov[-1]*pk1[-1]*(1.0 - pk1[-1]))/self.Nk[index]/M[-1]/M[-1]]\n",
    "\n",
    "            \n",
    "            self.s1 = s1\n",
    "            self.s2 = s2\n",
    "            self.pk1 = pk1\n",
    "            self.cov = cov\n",
    "            self.pk1 = pk1\n",
    "            self.pk2 = pk2\n",
    "            self.S = S\n",
    "            \n",
    "\n",
    "        tmp = 0.0\n",
    "        for i in range(self.Nexp):\n",
    "            tmp = tmp - np.log(self.S[i])/2.0 - ((self.delta[i]-self.pk1[i])**2)/self.S[i]/2.0\n",
    "                \n",
    "        self.log_lhd = tmp - self.Nexp*np.log(2.0*math.pi)/2.0\n",
    "    \n",
    "    def save_exp(self):\n",
    "        \n",
    "        file_name = 'EXP_T' + str(self.T) + '_Nexp' + str(self.Nexp) + '_N0' + str(self.N1) + '_pvec' + str(self.p[0])  + '_' + str(self.p[1])\n",
    "\n",
    "        name = os.path.join(dir_name, file_name)\n",
    "        pickle.dump( {'parameters':parameters, 'delta': self.delta, 'Tk': self.Tk, 'Nk': self.Nk, 'lhd': self.lhd_all}, open(name, 'wb'))\n",
    "        \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Synthetic data of model B\n",
    "\n",
    "Here we do MLE on model B. To do so, one needs to specify the **true model parameter** $\\mathbf{p}=(p, \\lambda, q)$, $N_1$, and $N_{exp}$. Note that the number of TICs in each of the $N_{exp}$ experiments is set to be $\\text{Poisson} (N_1)$ to account for variations. The $\\texttt{bayesian_TIC_exp}$ class generates synthetic data $\\mathcal{D} =\\{\\Delta_1(t_1, N_1), \\cdots, \\Delta_1(t_{10}, N_{10})\\}$, where $t_1 <t_2<\\cdots <t_{10}$. The goal is to do MLE based on $\\mathcal{D}$ to infer the true parameter.\n",
    "\n",
    "The $\\texttt{analyze_exp}$ attribute of this class analyze $\\mathcal{D}$ using MLE procedure outlined above. Note that this step invokes $\\texttt{compute_statistics_theory}$ attribute which computes the theoretically derived functions such as $\\sigma_i(t)$, $p_i(t)$, $\\Sigma_{12}(t), M(t)$ and $S^2(t)$ required to compute the log-likelihood. These expressions are provided in the note.\n",
    "\n",
    "To facilitate visualization, I assume that the DC division rate ($q$) is know so that we're only doing two-parameter inference, $\\boldsymbol{\\theta}_0=(p, \\lambda)$. The whole procedure is just one-liner (broken down into two lines for clarity) in the script below. The data is generated with $\\mathbf{p}=(p, \\lambda, q)= (0.7, 0.6, 0.5)$ on $N_{exp}=10$ experiments, each of which contains Poisson$(N_1=3000)$ TICs at the beginning. The gap between observations is set to 1 generation (can be arbitrary).\n",
    "\n",
    "The colormap indicates the log-likelihood $L_n(\\mathcal{D}|p,\\lambda)$. MLE result is marked as $\\hat{\\boldsymbol{\\theta}}_{MLE}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "parameters = {'pvec': [0.7, 0.6, 0.5], 'N1': 3000, 'T': 1, 'Nexp': 10}\n",
    "\n",
    "g = bayesian_TIC_exp(model_type = 'II', parameters = parameters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Synthetic data of model A\n",
    "\n",
    "Here we do MLE on model B. To do so, one needs to specify the **true model parameter** $\\mathbf{p}=(p_0, p_1, p_2)$, $N_1$, and $N_{exp}$. Note that the number of TICs in each of the $N_{exp}$ experiments is set to be $\\text{Poisson} (N_1)$ to account for variations. The $\\texttt{bayesian_TIC_exp}$ class generates synthetic data $\\mathcal{D} =\\{\\Delta_1(t_1, N_1), \\cdots, \\Delta_1(t_{10}, N_{10})\\}$, where $t_1 <t_2<\\cdots <t_{10}$. The goal is to do MLE based on $\\mathcal{D}$ to infer the true parameter.\n",
    "\n",
    "The $\\texttt{analyze_exp}$ attribute of this class analyze $\\mathcal{D}$ using MLE procedure outlined above. Note that this step invokes $\\texttt{compute_statistics_theory}$ attribute which computes the theoretically derived functions such as $\\sigma_i(t)$, $p_i(t)$, $\\Sigma_{12}(t), M(t)$ and $S^2(t)$ required to compute the log-likelihood. These expressions are provided in the note.\n",
    "\n",
    "In this case, we're only doing two-parameter inference, $\\boldsymbol{\\theta}_0=(p_1, p_2)$ since $p_0=1-p_1-p_2$ by conservation of probability. The whole procedure is just one-liner (broken down into two lines for clarity) in the script below. The data is generated with $\\mathbf{p}=(p_0, p_1, p_2)= (0.3, 0.5, 0.2)$ on $N_{exp}=70$ experiments, each of which contains Poisson$(N_1=200)$ TICs at the beginning. The gap between observations is set to 1 generation (can be arbitrary).\n",
    "\n",
    "The colormap indicates the log-likelihood $L_n(\\mathcal{D}|p_1,p_2)$. MLE result is marked as $\\hat{\\boldsymbol{\\theta}}_{MLE}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "parameters = {'pvec': [0.3, 0.5, 0.2], 'N1': 200, 'T': 1, 'Nexp': 70}\n",
    "\n",
    "g = bayesian_TIC_exp(model_type = 'I', parameters = parameters)"
   ]
  },
  {
   "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}