notes/DependentSampling.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import random\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tqdm\n",
    "from collections import defaultdict\n",
    "\n",
    "class HMM:\n",
    "    def __init__(self):\n",
    "        self.params = defaultdict(dict)\n",
    "        self.o2id,self.id2o = dict(),dict()\n",
    "        self.q2id,self.id2q = dict(),dict()\n",
    "        self.ct,self.ce = dict(),dict()\n",
    "    def _setDistinctObservations(self,distO):\n",
    "        self.o = len(distO)\n",
    "        for i,o in enumerate(distO):\n",
    "            self.o2id[o]=i\n",
    "            self.id2o[i]=o\n",
    "    def _setDistinctHiddens(self,distQ):\n",
    "        self.q = len(distQ)\n",
    "        A = np.random.uniform(0,1,(self.q,self.q))\n",
    "        A /= np.sum(A,axis=1,keepdims=1)\n",
    "        B = np.random.uniform(0,1,(self.q,self.o))\n",
    "        B /= np.sum(B,axis=1,keepdims=1)\n",
    "        pi = np.random.uniform(0,1,self.q)\n",
    "        pi/= np.sum(pi)\n",
    "        self.A = defaultdict(dict)\n",
    "        self.B = defaultdict(dict)\n",
    "        self.pi = {}\n",
    "        for i,q in enumerate(distQ):\n",
    "            self.q2id[q]=i\n",
    "            self.id2q[i]=q\n",
    "            for j,q_ in enumerate(distQ):\n",
    "                self.A[i][j] = A[i][j]\n",
    "            for k in range(self.o):\n",
    "                self.B[i][k] = B[i][k]\n",
    "            self.pi[i] = pi[i]\n",
    "    def setDistinctHiddensAndObservations(self,distO,distQ):\n",
    "        self._setDistinctObservations(distO)\n",
    "        self._setDistinctHiddens(distQ)\n",
    "    def setSpecificEmit(self,qSym,emitDict):\n",
    "        assert round(sum(emitDict.values()))==1, \"Sum of probability is not 1\"\n",
    "        for i in self.B[self.q2id[qSym]].keys():\n",
    "            # assert in dict\n",
    "            self.B[self.q2id[qSym]][i]=emitDict.get(self.id2o[i],0)\n",
    "        assert round(sum(self.B[self.q2id[qSym]].values()))==1, \"Sum of probability is not 1\"\n",
    "    def setSpecificTransit(self,qSym,tranDict):\n",
    "        assert round(sum(tranDict.values()))==1, \"Sum of probability is not 1\"\n",
    "        for i in self.A[self.q2id[qSym]].keys():\n",
    "            self.A[self.q2id[qSym]][i]=tranDict.get(self.id2q[i],0)\n",
    "        assert round(sum(self.A[self.q2id[qSym]].values()))==1, \"Sum of probability is not 1\"\n",
    "    def setInitial(self,initDict):\n",
    "        assert round(sum(initDict.values()))==1, \"Sum of probability is not 1\"\n",
    "        for i in self.pi.keys():\n",
    "            # assert in dict\n",
    "            self.pi[i]=initDict.get(self.id2q[i],0)\n",
    "        assert round(sum(self.pi.values()))==1, \"Sum of probability is not 1\"\n",
    "    def computeLikelihood(self,Os):\n",
    "        raise NotImplementedError(\"You need to implement function1 when you inherit from Model\")\n",
    "    def decode(self,Os):\n",
    "        raise NotImplementedError(\"You need to implement function1 when you inherit from Model\")\n",
    "    def learn(self,Qs,Os):\n",
    "        raise NotImplementedError(\"You need to implement function1 when you inherit from Model\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def likelihood(self,Os):\n",
    "    Length = len(Os)\n",
    "    alpha = np.zeros((self.q,Length))\n",
    "    for t,o in enumerate(Os):\n",
    "        for i in range(self.q):\n",
    "            if t==0:\n",
    "                alpha[i,t]=self.pi[i]*self.B[i][self.o2id[o]]\n",
    "            else:\n",
    "                for j in range(self.q):\n",
    "                    alpha[i,t]+=alpha[j,t-1]*self.A[j][i]\n",
    "                alpha[i,t]*=self.B[i][self.o2id[o]]\n",
    "    return sum(alpha[:,-1]),alpha\n",
    "def decode(self,Os):\n",
    "    Length = len(Os)\n",
    "    V = np.zeros((self.q,Length))\n",
    "    bt = [0]*Length\n",
    "    for t,o in enumerate(Os):\n",
    "        for i in range(self.q):\n",
    "            if t==0:\n",
    "                V[i,t]=self.pi[i]*self.B[i][self.o2id[o]]\n",
    "            else:\n",
    "                for j in range(self.q):\n",
    "                    V[i,t]=max(V[i,t],V[j,t-1]*self.A[j][i])\n",
    "                V[i,t]*=self.B[i][self.o2id[o]]\n",
    "        bt[t]=self.id2q[np.argmax(V[:,t])]\n",
    "    P_ = max(V[:,-1])\n",
    "    return P_,bt\n",
    "def samples(self,length):\n",
    "    Qs,Os = [],[]\n",
    "    for i in range(length):\n",
    "        if i==0:\n",
    "            q = np.random.choice(self.q,1,\n",
    "                    p=list(self.pi.values()))\n",
    "        else:\n",
    "            q = np.random.choice(self.q,1,\n",
    "                    p=list(self.A[q[0]].values()))\n",
    "        o = np.random.choice(self.o,1,\n",
    "                    p=list(self.B[q[0]].values()))\n",
    "        Qs.append(self.id2q[q[0]])\n",
    "        Os.append(self.id2o[o[0]])\n",
    "    return Qs,Os\n",
    "def learn(self,Qs,Os):\n",
    "    Length = len(Qs)\n",
    "    if Length==0: return \n",
    "    for i,(q,o) in enumerate(zip(Qs,Os)):\n",
    "        q_ = self.q2id[q]\n",
    "        o_ = self.o2id[o]\n",
    "        if i==0:\n",
    "            self.ct[None]=self.ct.get(None,0)+1\n",
    "            self.ct[(None,q_)]=self.ct.get((None,q_),0)+1\n",
    "        if i!=Length-1:\n",
    "            q_1 = self.q2id[Qs[i+1]]\n",
    "            self.ct[q_]=self.ct.get(q_,0)+1\n",
    "            self.ct[(q_,q_1)]=self.ct.get((q_,q_1),0)+1\n",
    "        self.ce[q_]=self.ce.get(q_,0)+1\n",
    "        self.ce[(q_,o_)]=self.ce.get((q_,o_),0)+1\n",
    "    for i in range(self.q):\n",
    "        self.pi[i]=self.ct.get((None,i),0)/self.ct.get(None,0)\n",
    "        for j in range(self.q):\n",
    "            self.A[i][j]=(self.ct.get((i,j),0)+1)/(self.ct.get(i,0)+self.q)\n",
    "        for o in range(self.o):\n",
    "            self.B[i][o]=(self.ce.get((i,o),0)+1)/(self.ce.get(i,0)+self.o)\n",
    "def add_patch(obj):\n",
    "    obj.computeLikelihood = lambda x:likelihood(obj,x)\n",
    "    obj.decode = lambda x:decode(obj,x)\n",
    "    obj.samples = lambda x: samples(obj,x)\n",
    "    obj.learn = lambda x,y: learn(obj,x,y)\n",
    "    return obj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def estimateT(s):\n",
    "    res,total = [],0\n",
    "    for i,n in enumerate(s):\n",
    "        total+=1+n\n",
    "        res.append(total/(i+1))\n",
    "    return res"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Markovian Die (Dependent Sampling) vs Die (Independent Sampling)\n",
    "- Examples of Independent Sampling\n",
    "    1. Importance Sampling\n",
    "    2. Inverse Transform\n",
    "    3. Rejection Sampling\n",
    "- Examples of Dependent Sampling\n",
    "    1. Random Walk Metropolis\n",
    "    2. Metropolis Hastings\n",
    "    3. HMC\n",
    "    4. Gibbs Sampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class experiment:\n",
    "    def __init__(self):\n",
    "        self.mu = 3.5\n",
    "        self._init_markovian_die()\n",
    "        self._init_die()\n",
    "    def _init_markovian_die(self):\n",
    "        mDie = HMM()\n",
    "        mDie.setDistinctHiddensAndObservations(\n",
    "            list(range(6)),list(range(6)))\n",
    "        mDie.setInitial({i:1/6 for i in range(6)})\n",
    "        mDie = add_patch(mDie)\n",
    "        for i in range(6):\n",
    "            if i==0:\n",
    "                mDie.setSpecificTransit(i,{5:0.5,i+1:0.5})\n",
    "            elif i==5:\n",
    "                mDie.setSpecificTransit(i,{i-1:0.5,0:0.5})\n",
    "            else:\n",
    "                mDie.setSpecificTransit(i,{i-1:0.5,i+1:0.5})\n",
    "        self.mDie = mDie\n",
    "    def _init_die(self):\n",
    "        die = HMM()\n",
    "        die.setDistinctHiddensAndObservations(\n",
    "            list(range(6)),list(range(6)))\n",
    "        die.setInitial({i:1/6 for i in range(6)})\n",
    "        die = add_patch(die)\n",
    "        for i in range(6):\n",
    "            die.setSpecificTransit(i,{i:1/6 for i in range(6)})\n",
    "        self.die = die\n",
    "    def single_experiment_compare_convergence(self,T):\n",
    "        Qsm,_ = self.mDie.samples(T)\n",
    "        Qs,_ = self.die.samples(T)\n",
    "        self.Qsm = Qsm\n",
    "        self.Qs = Qs\n",
    "        plt.plot(range(T),estimateT(Qsm),label='Markovian Die')\n",
    "        plt.plot(range(T),estimateT(Qs),label='Die')\n",
    "        plt.axhline(y=self.mu,label='Mean',color='r')\n",
    "        plt.ylabel('Expected Reward')\n",
    "        plt.xlabel('sample size')\n",
    "        plt.legend()\n",
    "    def single_experiment_uniformOrNot(self,Q):\n",
    "        _ = plt.hist(np.array(Q)+1,bins=6,\n",
    "                edgecolor='black',linewidth=1.2)\n",
    "        plt.xlabel('Face Value')\n",
    "        plt.ylabel('Count')\n",
    "    def multiple_experiments_errorHist(self,sampler,T=100,\n",
    "                iters=1000,plot=False):\n",
    "        mm,me = [],0\n",
    "        for i in tqdm(range(iters)):\n",
    "            Q,_ = sampler.samples(T)\n",
    "            dif = np.array(estimateT(Q))-self.mu\n",
    "            m = np.mean(dif)\n",
    "            me+=dif**2\n",
    "            mm.append(m)\n",
    "        me = np.sqrt(me/iters)\n",
    "        self.me,self.mm = me,mm\n",
    "        if plot:\n",
    "            _ = plt.hist(mm,bins=25,edgecolor='black',linewidth=1.2)\n",
    "            plt.xlabel('Error')\n",
    "            plt.ylabel('Count')\n",
    "    def multiple_experiments_effective_sample_size(self,\n",
    "                T=100,iters=1000):\n",
    "        self.multiple_experiments_errorHist(self.mDie,T,iters)\n",
    "        mem = self.me\n",
    "        self.multiple_experiments_errorHist(self.die,T,iters)\n",
    "        me = self.me\n",
    "        plt.plot(range(T),mem,label='Dependent')\n",
    "        plt.plot(range(T),me,label='Independent')\n",
    "        plt.xlabel('sample size')\n",
    "        plt.ylabel('average error (RMSE)')\n",
    "        plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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"
    }
   ],
   "source": [
    "e = experiment()\n",
    "e.single_experiment_compare_convergence(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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"
    }
   ],
   "source": [
    "e.single_experiment_uniformOrNot(e.Qsm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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"
    }
   ],
   "source": [
    "e.single_experiment_uniformOrNot(e.Qs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1000/1000 [00:03<00:00, 308.32it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEGCAYAAABy53LJAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAW2ElEQVR4nO3df5AkZ33f8fdXe5EEi1jtSYskJKK7q5wxFKkgbk1kcBmDiC2Ig2RHkuXC5gA5KmyMreAQC5MqpVJJWaRcQThOQS4g6yCUfhpKR8BQQj/schlkTkIGhCIkTj84S6tbfKshHtknbu+bP6YXDXu7O91z09Mzu+9X1dXOPP307Pd6Zvez/eN5OjITSZLKOq7pAiRJ48XgkCRVYnBIkioxOCRJlRgckqRKNjVdwLE49dRTc8uWLU2XIUlj5Z577vleZs70u35twRER1wI/DxzIzFcUbZuBG4EtwKPAJZm5EBEBfBh4M/AM8PbMvLfX99iyZQt79+6t5z8gSetURDx2LOvXeajqOuD8ZW1XArdn5nbg9uI5wJuA7cW/y4GP1FiXJOkY1BYcmfnnwMFlzRcAu4vHu4ELu9o/kR1fAU6OiDPqqk2S1L9hnxw/LTOfBCi+vqhoPxP4ble//UXbUSLi8ojYGxF75+fnay1WknS0UbmqKlZoW3EulMzclZmzmTk7M9P3uR1JUp+GHRxPLR2CKr4eKNr3Ay/p6ncW8MSQa5MklTDs4NgD7Cwe7wRu7Wp/W3ScC7SWDmlJkkZLnZfjXg/8DHBqROwHrgKuBm6KiMuAx4GLi+6fp3Mp7sN0Lsd9R111SZKOTW3BkZm/vMqi81bom8C766pFkjQ4Yz1yXBpHrVaLdrtduv/k5CRTU1M1ViRVY3BIQ9RqtTh76zZaC8uHOK1uanozjz2yz/DQyDA4pCFqt9u0Fg5y+s5rmJic7tl/sb3A3O4raLfbBodGhsEhNWBicppNJ53SdBlSXwwOaQzMzc2V7us5EdXN4JBG2JFDz8BxE+zYsaP0Op4TUd0MDmmE5eFDcGTRcyIaKQaHNAY8J6JRMiqTHEqSxoTBIUmqxOCQJFVicEiSKjE4JEmVeFWVdAyqTlhYZSCfNKoMDqlP/UxYKK0HBofUp6oTFgI8O/8o8zdfVXNlUr0MDukYVRmct9heqLkaqX6eHJckVWJwSJIqMTgkSZUYHJKkSgwOSVIlBockqRKDQ5JUicEhSarE4JAkVWJwSJIqMTgkSZUYHJKkSgwOSVIlBockqRKDQ5JUicEhSarE4JAkVdJIcETEv42I+yPimxFxfUScGBFbI+LuiHgoIm6MiOObqE2StLahB0dEnAn8FjCbma8AJoBLgQ8CH8rM7cACcNmwa5Mk9dbUoapNwPMiYhPwfOBJ4A3ALcXy3cCFDdUmSVrD0IMjM/8G+APgcTqB0QLuAZ7OzMNFt/3AmSutHxGXR8TeiNg7Pz8/jJIlSV2aOFQ1DVwAbAVeDEwCb1qha660fmbuyszZzJydmZmpr1BJ0oqaOFT1RuCRzJzPzB8AnwZeA5xcHLoCOAt4ooHaJEk9bOrdZeAeB86NiOcDfw+cB+wF7gQuAm4AdgK3NlCbtC7Mzc2V7js5OcnU1FSN1Wi9GXpwZObdEXELcC9wGPgasAv4HHBDRPznou3jw65NGndHDj0Dx02wY8eO0utMTW/msUf2GR4qrYk9DjLzKuCqZc37gFc3UI60buThQ3BkkdN3XsPE5HTP/ovtBeZ2X0G73TY4VFojwSGpXhOT02w66ZSmy9A65ZQjkqRKDA5JUiUGhySpEoNDklSJwSFJqsSrqrSutVot2u126f4OhpN6Mzi0brVaLc7euo3WwsHS6zgYTurN4NC61W63aS0cdDCcNGAGh9Y9B8NJg+XJcUlSJQaHJKkSg0OSVInBIUmqxOCQJFVicEiSKvFyXGmZsrddrXJ7Vmk9MTikQj+3XZU2IoNDKlS97eqz848yf/PyOyBL65/BIS1TdqT5YnthCNVIo8eT45KkSgwOSVIlBockqRKDQ5JUicEhSarE4JAkVWJwSJIqMTgkSZUYHJKkSgwOSVIlBockqRLnqlKjWq0W7Xa7dP/JyUmmpqZqrGhjqjJFvO+BDA41ptVqcfbWbbQWDpZeZ2p6M489ss9fXAPSz1TyvgcyONSYdrtNa+Fg6WnMF9sLzO2+gna77S+tAak6lbzvgaCh4IiIk4GPAa8AEngn8CBwI7AFeBS4JDOdt3oDKDuNuerje6Aqmjo5/mHgC5n548A/Ax4ArgRuz8ztwO3Fc0nSiBl6cETEC4GfBj4OkJnPZubTwAXA7qLbbuDCYdcmSeqtiT2ObcA88McR8bWI+FhETAKnZeaTAMXXF620ckRcHhF7I2Lv/Pz88KqWJAHNBMcm4FXARzLzHKBNhcNSmbkrM2czc3ZmZqauGiVJq2giOPYD+zPz7uL5LXSC5KmIOAOg+HqggdokST0MPTgycw74bkS8tGg6D/gWsAfYWbTtBG4ddm2SpN6aGsfxHuBTEXE8sA94B50QuykiLgMeBy5uqDZJ0hoaCY7MvA+YXWHRecOuRZJUjZMcSpIqKRUcEfHaMm2SpPWv7B7Hfy/ZJkla59Y8xxERPwm8BpiJiPd2LXohMFFnYZKk0dTr5PjxwAuKfid1tX8fuKiuoiRJo2vN4MjMPwP+LCKuy8zHhlSTJGmElb0c94SI2EVnyvMfrpOZb6ijKGktZe9WV+WudpLKKxscNwMfpXMPjcX6ypFW18/d6iQNXtngOJyZH6m1EqmHqnere3b+UeZvvmoIlUkbS9ng+GxE/AbwGeDQUmNmlr9ZtDQgZe9Wt9j2BpJSHcoGx9Lkg+/raks699aQJG0gpYIjM7fWXYgkaTyUCo6IeNtK7Zn5icGWI0kadWUPVf1E1+MT6cxiey9gcEjSBlP2UNV7up9HxBTwyVoqkiSNtH6nVX8G2D7IQiRJ46HsOY7P0rmKCjqTG74MuKmuoiRJo6vsOY4/6Hp8GHgsM/fXUI8kacSVOlRVTHb4f+nMkDsNPFtnUZKk0VX2DoCXAH8FXAxcAtwdEU6rLkkbUNlDVR8AfiIzDwBExAzwJeCWugqTNLqqzDx8+PBhNm0q+6umY3JykqmpqaplaUjKvpvHLYVG4W/p/4osSWOqnxmKY2ITuXi40veZmt7MY4/sMzxGVNng+EJEfBG4vnj+S8Dn6ylJ0qjqd4bisv2hMznl3O4raLfbBseI6nXP8X8CnJaZ74uIXwR+Cgjgy8CnhlCfxkyr1aLdbpfq642WxlfVGYrL9td46LXHcQ3wewCZ+Wng0wARMVss+1e1Vqex0mq1OHvrNloLzrYvrWe9gmNLZn59eWNm7o2ILbVUpLHVbrdpLRz0RkvSOtcrOE5cY9nzBlmI1g9vtCStb72ujPpqRPyb5Y0RcRlwTz0lSZJGWa89jiuAz0TEW3kuKGaB44FfqLMwSdJoWjM4MvMp4DUR8XrgFUXz5zLzjtorkySNpLL347gTuLPmWiRJY8DR35KkSgwOSVIljQVHRExExNci4v8Uz7dGxN0R8VBE3BgRxzdVmyRpdU3ucfw28EDX8w8CH8rM7cACcFkjVUmS1tRIcETEWcC/BD5WPA/gDTw3Tftu4MImapMkra2pPY5rgH8PHCmenwI8nZlLcy/vB85cacWIuDwi9kbE3vn5+forlST9iKEHR0T8PHAgM7tHnscKXXOl9TNzV2bOZubszMxMLTVKklZX7bZcg/Fa4C0R8WY6c2G9kM4eyMkRsanY6zgLeKKB2iRJPQx9jyMz35+ZZ2XmFuBS4I7MfCudAYZL9zHfCdw67NokSb2N0jiO3wXeGxEP0znn8fGG65EkraCJQ1U/lJl3AXcVj/cBr26yHklSb6O0xyFJGgMGhySpkkYPVUnSaubm5kr3nZycZGpqqsZq1M3gkDRSjhx6Bo6bYMeOHaXXmZrezGOP7DM8hsTgkDRS8vAhOLLI6TuvYWJyumf/xfYCc7uvoN1uGxxDYnBIGkkTk9NsOumUpsvQCgwOrarVatFut0v3r3JMWtL4Mji0olarxdlbt9FaONh0KZJGjMGhFbXbbVoLB0sfZwZ4dv5R5m++qubKJDXN4NCaqhxnXmwv1FyNpFHgAEBJUiUGhySpEoNDklSJwSFJqsTgkCRVYnBIkioxOCRJlRgckqRKDA5JUiUGhySpEoNDklSJc1VJWhe81ezwGBySxpq3mh0+g0PSWPNWs8NncEhaF7zV7PB4clySVInBIUmqxOCQJFVicEiSKjE4JEmVGBySpEoMDklSJQaHJKkSg0OSVMnQgyMiXhIRd0bEAxFxf0T8dtG+OSJui4iHiq+95w6QJA1dE3sch4HfycyXAecC746IlwNXArdn5nbg9uK5JGnEDD04MvPJzLy3ePz/gAeAM4ELgN1Ft93AhcOuTZLUW6PnOCJiC3AOcDdwWmY+CZ1wAV60yjqXR8TeiNg7Pz8/rFIlSYXGgiMiXgD8CXBFZn6/7HqZuSszZzNzdmZmpr4CJUkraiQ4IuIf0QmNT2Xmp4vmpyLijGL5GcCBJmqTJK2tiauqAvg48EBm/reuRXuAncXjncCtw65NktRbEzdyei3wq8A3IuK+ou33gKuBmyLiMuBx4OIGapMk9TD04MjMvwBilcXnDbMWSVJ1jhyXJFVicEiSKmniHIca0mq1aLfbpfrOzc3VXI2kcWVwbBCtVouzt26jtXCw6VIkjTmDY4Not9u0Fg5y+s5rmJjsPX/ks/OPMn/zVUOoTNK4MTg2mInJaTaddErPfovthSFUI2kcGRxjzHMWUv+q/ExMTk4yNTVVYzXjxeAYU56zkPpz5NAzcNwEO3bsKL3O1PRmHntkn+FRMDjGlOcspP7k4UNwZLH0z85ie4G53VfQbrcNjoLBMeY8ZyH1p+zPjo5mcEhSCZ4TeY7BIUlr8JzI0QwOSVqD50SOZnBIUgmeE3mOkxxKkioxOCRJlRgckqRKDA5JUiUGhySpEq+qkqQarOcBgwaHJA3QRhgwaHBI0gBthAGDBock1WA9Dxg0OEaIN2aSNA4MjhHhjZkkjQuDY0R4YyZJ48LgGDHemEnSqHMAoCSpEoNDklTJhj1UVeUKJuhvZKdXSUkqq+rvgCZHm2/I4OjnCqaqIzu9SkpSGf2MNIdmR5tvyOCoegVTPyM7vUpKUhlVR5pD86PNN2RwLKk6srPKruRSX6+SklTGOI0039DBUVa/u5KStB6NVHBExPnAh4EJ4GOZeXXDJQH97Up66EnSejUywRERE8D/AP4FsB/4akTsycxvNVvZc6rsSnroSdJ6NTLBAbwaeDgz9wFExA3ABUBtwVH2l/viM61K/ftZZ9z7j2JNo9Z/FGsatf6jWNOo9a/atw6RmY0WsCQiLgLOz8xfK57/KvDPM/M3l/W7HLi8ePpS4MEBl3Iq8L0Bv+agWFt/rK0/1tafcajt7Myc6fdFRmmPI1ZoOyrVMnMXsKu2IiL2ZuZsXa9/LKytP9bWH2vrz0aobZSmHNkPvKTr+VnAEw3VIklaxSgFx1eB7RGxNSKOBy4F9jRckyRpmZE5VJWZhyPiN4Ev0rkc99rMvL+BUmo7DDYA1tYfa+uPtfVn3dc2MifHJUnjYZQOVUmSxoDBIUmqZEMGR0RcHBH3R8SRiFj10rSIOD8iHoyIhyPiyq72rRFxd0Q8FBE3FifzB1Xb5oi4rXjt2yLiqDlOIuL1EXFf179/iIgLi2XXRcQjXcteOczain6LXd9/T1d709vtlRHx5eK9/3pE/FLXsoFut9U+O13LTyi2wcPFNtnStez9RfuDEfFzx1JHn7W9NyK+VWyj2yPi7K5lK763Q6zt7REx31XDr3Ut21m8/w9FxM4GavtQV13fjoinu5bVvd2ujYgDEfHNVZZHRPxhUfvXI+JVXcuqb7fM3HD/gJfRGTx4FzC7Sp8J4DvANuB44K+BlxfLbgIuLR5/FPj1Adb2X4Eri8dXAh/s0X8zcBB4fvH8OuCimrZbqdqAv1ulvdHtBvwYsL14/GLgSeDkQW+3tT47XX1+A/ho8fhS4Mbi8cuL/icAW4vXmRjgdipT2+u7Pk+/vlTbWu/tEGt7O/BHK6y7GdhXfJ0uHk8Ps7Zl/d9D5wKf2rdb8fo/DbwK+OYqy98M/Cmd8XLnAncfy3bbkHscmflAZvYacf7DKVAy81ngBuCCiAjgDcAtRb/dwIUDLO+C4jXLvvZFwJ9m5jMDrGE1VWv7oVHYbpn57cx8qHj8BHAA6Hv07BpW/OysUe8twHnFNroAuCEzD2XmI8DDxesNrbbMvLPr8/QVOmOqhqHMdlvNzwG3ZebBzFwAbgPOb7C2XwauH+D3X1Nm/jmdPyBXcwHwiez4CnByRJxBn9ttQwZHSWcC3+16vr9oOwV4OjMPL2sflNMy80mA4uuLevS/lKM/oP+l2B39UESc0EBtJ0bE3oj4ytIhNEZsu0XEq+n85fidruZBbbfVPjsr9im2SYvONiqz7rGo+vqX0flLdclK7+2wa/vXxft0S0QsDRoeme1WHNrbCtzR1Vznditjtfr72m4jM45j0CLiS8DpKyz6QGbeWuYlVmjLNdoHUlvF1zkD+Kd0xr4seT8wR+eX4i7gd4H/NOTa/nFmPhER24A7IuIbwPdX6NfkdvsksDMzjxTNx7Tdln+LFdqW/19r+3z1UPr1I+JXgFngdV3NR723mfmdldavqbbPAtdn5qGIeBedvbY3lFy37tqWXArckpmLXW11brcyBvp5W7fBkZlvPMaXWG0KlO/R2c3bVPylWHlqlLVqi4inIuKMzHyy+AV3YI2XugT4TGb+oOu1nyweHoqIPwb+3bBrKw4DkZn7IuIu4BzgTxiB7RYRLwQ+B/yHYpd96bWPabstU2b6nKU++yNiEzBF51BD3VPvlHr9iHgjnUB+XWYeWmpf5b0d1C/AnrVl5t92Pf1fwAe71v2ZZeveNaC6StXW5VLg3d0NNW+3Mlarv6/t5qGq1a04BUp2zijdSefcAsBOoMweTFl7itcs89pHHUctfmkunVO4EFjxKou6aouI6aXDPBFxKvBa4FujsN2K9/EzdI713rxs2SC3W5npc7rrvQi4o9hGe4BLo3PV1VZgO/BXx1BL5doi4hzgfwJvycwDXe0rvrdDru2MrqdvAR4oHn8R+NmixmngZ/nRPfHaayvqeymdk8xf7mqre7uVsQd4W3F11blAq/hjqb/tVueZ/lH9B/wCnaQ9BDwFfLFofzHw+a5+bwa+Tecvgw90tW+j88P8MHAzcMIAazsFuB14qPi6uWifpXNXxKV+W4C/AY5btv4dwDfo/OL738ALhlkb8Jri+/918fWyUdluwK8APwDu6/r3yjq220qfHTqHvt5SPD6x2AYPF9tkW9e6HyjWexB4Uw2f/161fan4uVjaRnt6vbdDrO33gfuLGu4Efrxr3XcW2/Nh4B3Drq14/h+Bq5etN4ztdj2dqwR/QOd322XAu4B3FcuDzo3yvlPUMNu1buXt5pQjkqRKPFQlSarE4JAkVWJwSJIqMTgkSZUYHJKkStbtAEBp0CJikc6ljEtuyMyrm6pHaoqX40olRcTfZeYLevSZyK6pJrpGyvd67VL9pFHgHod0jCLiUeBaOqNu/6iYQ+kv6YwQ3hMRtxTLZ4B5OoOsHo+I6+hMM3IOcC/wO8OvXqrO4JDKe15E3Nf1/Pcz88bi8T9k5k8BFMFxcma+rnj+WTrTnOyOiHcCf8hz077/GPDG/NEJ8aSRZnBI5f19Zq52Z8Ab13j+k8AvFo8/SeemU0tuNjQ0bryqShqMdo/n3bpPLK7VTxpJBodUv7+kM5sqwFuBv2iwFumYeahKKm/5OY4vZOaVJdb7LeDaiHgfxcnxWqqThsTLcSVJlXioSpJUicEhSarE4JAkVWJwSJIqMTgkSZUYHJKkSgwOSVIl/x85yR1mG4uDVgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "e.multiple_experiments_errorHist(e.mDie,T=100,iters=1000,plot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1000/1000 [00:03<00:00, 300.76it/s]\n"
     ]
    },
    {
     "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": [
    "e.multiple_experiments_errorHist(e.die,T=100,iters=1000,plot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1000/1000 [00:03<00:00, 306.22it/s]\n",
      "100%|██████████| 1000/1000 [00:03<00:00, 308.34it/s]\n"
     ]
    },
    {
     "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": [
    "e.multiple_experiments_effective_sample_size()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Effective Sample Size** is defined as follows,\n",
    "$$ESS = \\frac{mT}{1+\\sum_{J=1}^{T'}\\hat{\\rho}_J}$$\n",
    "\n",
    "where m total sample size, T sample size for each markov chain, $\\hat{\\rho}$ autocorrelation which the slope between $\\theta_t$ and $\\{\\theta\\}_{0}^{t-1}$.\n",
    "\n",
    "1. I guess, markovian die has $\\rho=2$ and die has $\\rho=6$, so die has better effective sample size. \n",
    "2. The higher the autocorrelation is, the lower the ESS."
   ]
  },
  {
   "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}