notebooks/variational_inference/lda-advi-aevb.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Automatic autoencoding variational Bayes for latent dirichlet allocation with PyMC3\n",
    "\n",
    "For probabilistic models with latent variables, autoencoding variational Bayes (AEVB; Kingma and Welling, 2014) is an algorithm which allows us to perform inference efficiently for large datasets with an encoder. In AEVB, the encoder is used to infer variational parameters of approximate posterior on latent variables from given samples. By using tunable and flexible encoders such as multilayer perceptrons (MLPs), AEVB approximates complex variational posterior based on mean-field approximation, which does not utilize analytic representations of the true posterior. Combining AEVB with ADVI (Kucukelbir et al., 2015), we can perform posterior inference on almost arbitrary probabilistic models involving continuous latent variables. \n",
    "\n",
    "I have implemented AEVB for ADVI with mini-batch on PyMC3. To demonstrate flexibility of this approach, we will apply this to latent dirichlet allocation (LDA; Blei et al., 2003) for modeling documents. In the LDA model, each document is assumed to be generated from a multinomial distribution, whose parameters are treated as latent variables. By using AEVB with an MLP as an encoder, we will fit the LDA model to the 20-newsgroups dataset. \n",
    "\n",
    "In this example, extracted topics by AEVB seem to be qualitatively comparable to those with a standard LDA implementation, i.e., online VB implemented on scikit-learn. Unfortunately, the predictive accuracy of unseen words is less than the standard implementation of LDA, it might be due to the mean-field approximation. However, the combination of AEVB and ADVI allows us to quickly apply more complex probabilistic models than LDA to big data with the help of mini-batches. I hope this notebook will attract readers, especially practitioners working on a variety of machine learning tasks, to probabilistic programming and PyMC3. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "env: THEANO_FLAGS=device=cpu,floatX=float64\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import os\n",
    "import sys\n",
    "\n",
    "from collections import OrderedDict\n",
    "from copy import deepcopy\n",
    "from time import time\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pymc3 as pm\n",
    "import seaborn as sns\n",
    "import theano\n",
    "import theano.tensor as tt\n",
    "\n",
    "from pymc3 import Dirichlet\n",
    "from pymc3 import math as pmmath\n",
    "from sklearn.datasets import fetch_20newsgroups\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n",
    "from theano import shared\n",
    "from theano.sandbox.rng_mrg import MRG_RandomStreams\n",
    "\n",
    "# unfortunately I was not able to run it on GPU due to overflow problems\n",
    "%env THEANO_FLAGS=device=cpu,floatX=float64\n",
    "\n",
    "plt.style.use(\"seaborn-darkgrid\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dataset\n",
    "Here, we will use the 20-newsgroups dataset. This dataset can be obtained by using functions of scikit-learn. The below code is partially adopted from an example of scikit-learn (http://scikit-learn.org/stable/auto_examples/applications/topics_extraction_with_nmf_lda.html). We set the number of words in the vocabulary to 1000.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading dataset...\n",
      "done in 1.724s.\n",
      "Extracting tf features for LDA...\n",
      "done in 2.177s.\n"
     ]
    }
   ],
   "source": [
    "# The number of words in the vocabulary\n",
    "n_words = 1000\n",
    "\n",
    "print(\"Loading dataset...\")\n",
    "t0 = time()\n",
    "dataset = fetch_20newsgroups(shuffle=True, random_state=1, remove=(\"headers\", \"footers\", \"quotes\"))\n",
    "data_samples = dataset.data\n",
    "print(\"done in %0.3fs.\" % (time() - t0))\n",
    "\n",
    "# Use tf (raw term count) features for LDA.\n",
    "print(\"Extracting tf features for LDA...\")\n",
    "tf_vectorizer = CountVectorizer(max_df=0.95, min_df=2, max_features=n_words, stop_words=\"english\")\n",
    "\n",
    "t0 = time()\n",
    "tf = tf_vectorizer.fit_transform(data_samples)\n",
    "feature_names = tf_vectorizer.get_feature_names()\n",
    "print(\"done in %0.3fs.\" % (time() - t0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each document is represented by 1000-dimensional term-frequency vector. Let's check the data. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(tf[:10, :].toarray().T);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We split the whole documents into training and test sets. The number of tokens in the training set is 480K. Sparsity of the term-frequency document matrix is 0.025%, which implies almost all components in the term-frequency matrix is zero. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of docs for training = 10000\n",
      "Number of docs for test = 1314\n",
      "Number of tokens in training set = 480263\n",
      "Sparsity = 0.0253936\n"
     ]
    }
   ],
   "source": [
    "n_samples_tr = 10000\n",
    "n_samples_te = tf.shape[0] - n_samples_tr\n",
    "docs_tr = tf[:n_samples_tr, :]\n",
    "docs_te = tf[n_samples_tr:, :]\n",
    "print(\"Number of docs for training = {}\".format(docs_tr.shape[0]))\n",
    "print(\"Number of docs for test = {}\".format(docs_te.shape[0]))\n",
    "\n",
    "n_tokens = np.sum(docs_tr[docs_tr.nonzero()])\n",
    "print(f\"Number of tokens in training set = {n_tokens}\")\n",
    "print(\n",
    "    \"Sparsity = {}\".format(len(docs_tr.nonzero()[0]) / float(docs_tr.shape[0] * docs_tr.shape[1]))\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Log-likelihood of documents for LDA\n",
    "For a document $d$ consisting of tokens $w$, the log-likelihood of the LDA model with $K$ topics is given as\n",
    "\\begin{eqnarray}\n",
    "    \\log p\\left(d|\\theta_{d},\\beta\\right) & = & \\sum_{w\\in d}\\log\\left[\\sum_{k=1}^{K}\\exp\\left(\\log\\theta_{d,k} + \\log \\beta_{k,w}\\right)\\right]+const, \n",
    "\\end{eqnarray}\n",
    "where $\\theta_{d}$ is the topic distribution for document $d$ and $\\beta$ is the word distribution for the $K$ topics. We define a function that returns a tensor of the log-likelihood of documents given $\\theta_{d}$ and $\\beta$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def logp_lda_doc(beta, theta):\n",
    "    \"\"\"Returns the log-likelihood function for given documents.\n",
    "\n",
    "    K : number of topics in the model\n",
    "    V : number of words (size of vocabulary)\n",
    "    D : number of documents (in a mini-batch)\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    beta : tensor (K x V)\n",
    "        Word distributions.\n",
    "    theta : tensor (D x K)\n",
    "        Topic distributions for documents.\n",
    "    \"\"\"\n",
    "\n",
    "    def ll_docs_f(docs):\n",
    "        dixs, vixs = docs.nonzero()\n",
    "        vfreqs = docs[dixs, vixs]\n",
    "        ll_docs = (\n",
    "            vfreqs * pmmath.logsumexp(tt.log(theta[dixs]) + tt.log(beta.T[vixs]), axis=1).ravel()\n",
    "        )\n",
    "\n",
    "        # Per-word log-likelihood times num of tokens in the whole dataset\n",
    "        return tt.sum(ll_docs) / (tt.sum(vfreqs) + 1e-9) * n_tokens\n",
    "\n",
    "    return ll_docs_f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the inner function, the log-likelihood is scaled for mini-batches by the number of tokens in the dataset. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LDA model\n",
    "With the log-likelihood function, we can construct the probabilistic model for LDA. `doc_t` works as a placeholder to which documents in a mini-batch are set.  \n",
    "\n",
    "For ADVI, each of random variables $\\theta$ and $\\beta$, drawn from Dirichlet distributions, is transformed into unconstrained real coordinate space. To do this, by default, PyMC3 uses an isometric logratio transformation. Since these random variables are on a simplex, the dimension of the unconstrained coordinate space is the original dimension minus 1. For example, the dimension of $\\theta_{d}$ is the number of topics (`n_topics`) in the LDA model, thus the transformed space has dimension `(n_topics - 1)`. \n",
    "\n",
    "The variational posterior on these transformed parameters is represented by a spherical Gaussian distributions (meanfield approximation). Thus, the number of variational parameters of $\\theta_{d}$, the latent variable for each document, is `2 * (n_topics - 1)` for means and standard deviations. \n",
    "\n",
    "In the last line of the below cell, `DensityDist` class is used to define the log-likelihood function of the model. The second argument is a Python function which takes observations (a document matrix in this example) and returns the log-likelihood value. This function is given as a return value of `logp_lda_doc(beta, theta)`, which has been defined above. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      ".../lib/python3.7/site-packages/pymc3/data.py:305: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  self.shared = theano.shared(data[in_memory_slc])\n"
     ]
    }
   ],
   "source": [
    "n_topics = 10\n",
    "# we have sparse dataset. It's better to have dence batch so that all words accure there\n",
    "minibatch_size = 128\n",
    "\n",
    "# defining minibatch\n",
    "doc_t_minibatch = pm.Minibatch(docs_tr.toarray(), minibatch_size)\n",
    "doc_t = shared(docs_tr.toarray()[:minibatch_size])\n",
    "with pm.Model() as model:\n",
    "    theta = Dirichlet(\n",
    "        \"theta\",\n",
    "        a=pm.floatX((1.0 / n_topics) * np.ones((minibatch_size, n_topics))),\n",
    "        shape=(minibatch_size, n_topics),\n",
    "        # do not forget scaling\n",
    "        total_size=n_samples_tr,\n",
    "    )\n",
    "    beta = Dirichlet(\n",
    "        \"beta\",\n",
    "        a=pm.floatX((1.0 / n_topics) * np.ones((n_topics, n_words))),\n",
    "        shape=(n_topics, n_words),\n",
    "    )\n",
    "    # Note, that we defined likelihood with scaling, so here we need no additional `total_size` kwarg\n",
    "    doc = pm.DensityDist(\"doc\", logp_lda_doc(beta, theta), observed=doc_t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Encoder\n",
    "Given a document, the encoder calculates variational parameters of the (transformed) latent variables, more specifically, parameters of Gaussian distributions in the unconstrained real coordinate space. The `encode()` method is required to output variational means and stds as a tuple, as shown in the following code. As explained above, the number of variational parameters is `2 * (n_topics) - 1`. Specifically, the shape of `zs_mean` (or `zs_std`) in the method is `(minibatch_size, n_topics - 1)`. It should be noted that `zs_std` is defined as $\\rho = log(exp(std) - 1)$ in `ADVI` and bounded to be positive. The inverse parametrization is $std = log(1+exp(\\rho))$ and considered to be numericaly stable.\n",
    "\n",
    "To enhance generalization ability to unseen words, a bernoulli corruption process is applied to the inputted documents. Unfortunately, I have never see any significant improvement with this. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LDAEncoder:\n",
    "    \"\"\"Encode (term-frequency) document vectors to variational means and (log-transformed) stds.\"\"\"\n",
    "\n",
    "    def __init__(self, n_words, n_hidden, n_topics, p_corruption=0, random_seed=1):\n",
    "        rng = np.random.RandomState(random_seed)\n",
    "        self.n_words = n_words\n",
    "        self.n_hidden = n_hidden\n",
    "        self.n_topics = n_topics\n",
    "        self.w0 = shared(0.01 * rng.randn(n_words, n_hidden).ravel(), name=\"w0\")\n",
    "        self.b0 = shared(0.01 * rng.randn(n_hidden), name=\"b0\")\n",
    "        self.w1 = shared(0.01 * rng.randn(n_hidden, 2 * (n_topics - 1)).ravel(), name=\"w1\")\n",
    "        self.b1 = shared(0.01 * rng.randn(2 * (n_topics - 1)), name=\"b1\")\n",
    "        self.rng = MRG_RandomStreams(seed=random_seed)\n",
    "        self.p_corruption = p_corruption\n",
    "\n",
    "    def encode(self, xs):\n",
    "        if 0 < self.p_corruption:\n",
    "            dixs, vixs = xs.nonzero()\n",
    "            mask = tt.set_subtensor(\n",
    "                tt.zeros_like(xs)[dixs, vixs],\n",
    "                self.rng.binomial(size=dixs.shape, n=1, p=1 - self.p_corruption),\n",
    "            )\n",
    "            xs_ = xs * mask\n",
    "        else:\n",
    "            xs_ = xs\n",
    "\n",
    "        w0 = self.w0.reshape((self.n_words, self.n_hidden))\n",
    "        w1 = self.w1.reshape((self.n_hidden, 2 * (self.n_topics - 1)))\n",
    "        hs = tt.tanh(xs_.dot(w0) + self.b0)\n",
    "        zs = hs.dot(w1) + self.b1\n",
    "        zs_mean = zs[:, : (self.n_topics - 1)]\n",
    "        zs_rho = zs[:, (self.n_topics - 1) :]\n",
    "        return {\"mu\": zs_mean, \"rho\": zs_rho}\n",
    "\n",
    "    def get_params(self):\n",
    "        return [self.w0, self.b0, self.w1, self.b1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To feed the output of the encoder to the variational parameters of $\\theta$, we set an OrderedDict of tuples as below.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([(theta ~ Dirichlet(a=array),\n",
       "              {'mu': Subtensor{::, :int64:}.0,\n",
       "               'rho': Subtensor{::, int64::}.0})])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "encoder = LDAEncoder(n_words=n_words, n_hidden=100, n_topics=n_topics, p_corruption=0.0)\n",
    "local_RVs = OrderedDict([(theta, encoder.encode(doc_t))])\n",
    "local_RVs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`theta` is the random variable defined in the model creation and is a key of an entry of the `OrderedDict`. The value `(encoder.encode(doc_t), n_samples_tr / minibatch_size)` is a tuple of a theano expression and a scalar. The theano expression `encoder.encode(doc_t)` is the output of the encoder given inputs (documents). The scalar `n_samples_tr / minibatch_size` specifies the scaling factor for mini-batches. \n",
    "\n",
    "ADVI optimizes the parameters of the encoder. They are passed to the function for ADVI. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[w0, b0, w1, b1]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "encoder_params = encoder.get_params()\n",
    "encoder_params"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## AEVB with ADVI"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "        <style>\n",
       "            /* Turns off some styling */\n",
       "            progress {\n",
       "                /* gets rid of default border in Firefox and Opera. */\n",
       "                border: none;\n",
       "                /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "                background-size: auto;\n",
       "            }\n",
       "            .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "                background: #F44336;\n",
       "            }\n",
       "        </style>\n",
       "      <progress value='10000' class='' max='10000' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      100.00% [10000/10000 08:11<00:00 Average Loss = 3.0171e+06]\n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Finished [100%]: Average Loss = 3.0204e+06\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<pymc3.variational.approximations.MeanField at 0x7fef38dc3e50>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "η = 0.1\n",
    "s = shared(η)\n",
    "\n",
    "\n",
    "def reduce_rate(a, h, i):\n",
    "    s.set_value(η / ((i / minibatch_size) + 1) ** 0.7)\n",
    "\n",
    "\n",
    "with model:\n",
    "    approx = pm.MeanField(local_rv=local_RVs)\n",
    "    approx.scale_cost_to_minibatch = False\n",
    "    inference = pm.KLqp(approx)\n",
    "inference.fit(\n",
    "    10000,\n",
    "    callbacks=[reduce_rate],\n",
    "    obj_optimizer=pm.sgd(learning_rate=s),\n",
    "    more_obj_params=encoder_params,\n",
    "    total_grad_norm_constraint=200,\n",
    "    more_replacements={doc_t: doc_t_minibatch},\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Approximation{MeanFieldGroup[None, 9] & MeanFieldGroup[9990]}\n"
     ]
    }
   ],
   "source": [
    "print(approx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(approx.hist[10:]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extraction of characteristic words of topics based on posterior samples\n",
    "By using estimated variational parameters, we can draw samples from the variational posterior. To do this, we use function `sample_vp()`. Here we use this function to obtain posterior mean of the word-topic distribution $\\beta$ and show top-10 words frequently appeared in the 10 topics. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To apply the above function for the LDA model, we redefine the probabilistic model because the number of documents to be tested changes. Since variational parameters have already been obtained, we can reuse them for sampling from the approximate posterior distribution. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Topic #0: car good just like use new used power don time\n",
      "Topic #1: space key information use encryption new chip data public edu\n",
      "Topic #2: don like just know people think ve time good want\n",
      "Topic #3: year people said just team don like time think game\n",
      "Topic #4: file use windows edu drive program scsi does using like\n",
      "Topic #5: 00 10 25 15 11 17 20 16 12 14\n",
      "Topic #6: ax max g9v b8f a86 75u pl bhj giz 1t\n",
      "Topic #7: people god think don does just know believe say said\n",
      "Topic #8: young just people know don like think does work good\n",
      "Topic #9: like just know don think does people use time good\n"
     ]
    }
   ],
   "source": [
    "def print_top_words(beta, feature_names, n_top_words=10):\n",
    "    for i in range(len(beta)):\n",
    "        print(\n",
    "            (\"Topic #%d: \" % i)\n",
    "            + \" \".join([feature_names[j] for j in beta[i].argsort()[: -n_top_words - 1 : -1]])\n",
    "        )\n",
    "\n",
    "\n",
    "doc_t.set_value(docs_tr.toarray())\n",
    "samples = pm.sample_approx(approx, draws=100)\n",
    "beta_pymc3 = samples[\"beta\"].mean(axis=0)\n",
    "\n",
    "print_top_words(beta_pymc3, feature_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We compare these topics to those obtained by a standard LDA implementation on scikit-learn, which is based on an online stochastic variational inference (Hoffman et al., 2013). We can see that estimated words in the topics are qualitatively similar. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 39.7 s, sys: 50.8 ms, total: 39.8 s\n",
      "Wall time: 39.8 s\n",
      "Topic #0: people gun armenian war armenians turkish states said state 000\n",
      "Topic #1: government people law mr president use don think right public\n",
      "Topic #2: space science nasa program data research center output earth launch\n",
      "Topic #3: key car chip used keys bit bike clipper use number\n",
      "Topic #4: edu file com mail available ftp image files information list\n",
      "Topic #5: god people does jesus think believe don say just know\n",
      "Topic #6: windows drive use thanks does card know problem like db\n",
      "Topic #7: ax max g9v pl b8f a86 cx 34u 145 1t\n",
      "Topic #8: just don like know think good time ve people year\n",
      "Topic #9: 00 10 25 15 20 12 11 16 14 17\n"
     ]
    }
   ],
   "source": [
    "from sklearn.decomposition import LatentDirichletAllocation\n",
    "\n",
    "lda = LatentDirichletAllocation(\n",
    "    n_components=n_topics,\n",
    "    max_iter=5,\n",
    "    learning_method=\"online\",\n",
    "    learning_offset=50.0,\n",
    "    random_state=0,\n",
    ")\n",
    "%time lda.fit(docs_tr)\n",
    "beta_sklearn = lda.components_ / lda.components_.sum(axis=1)[:, np.newaxis]\n",
    "\n",
    "print_top_words(beta_sklearn, feature_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Predictive distribution\n",
    "In some papers (e.g., Hoffman et al. 2013), the predictive distribution of held-out words was proposed as a quantitative measure for goodness of the model fitness. The log-likelihood function for tokens of the held-out word can be calculated with posterior means of $\\theta$ and $\\beta$. The validity of this is explained in (Hoffman et al. 2013). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calc_pp(ws, thetas, beta, wix):\n",
    "    \"\"\"\n",
    "    Parameters\n",
    "    ----------\n",
    "    ws: ndarray (N,)\n",
    "        Number of times the held-out word appeared in N documents.\n",
    "    thetas: ndarray, shape=(N, K)\n",
    "        Topic distributions for N documents.\n",
    "    beta: ndarray, shape=(K, V)\n",
    "        Word distributions for K topics.\n",
    "    wix: int\n",
    "        Index of the held-out word\n",
    "\n",
    "    Return\n",
    "    ------\n",
    "    Log probability of held-out words.\n",
    "    \"\"\"\n",
    "    return ws * np.log(thetas.dot(beta[:, wix]))\n",
    "\n",
    "\n",
    "def eval_lda(transform, beta, docs_te, wixs):\n",
    "    \"\"\"Evaluate LDA model by log predictive probability.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    transform: Python function\n",
    "        Transform document vectors to posterior mean of topic proportions.\n",
    "    wixs: iterable of int\n",
    "        Word indices to be held-out.\n",
    "    \"\"\"\n",
    "    lpss = []\n",
    "    docs_ = deepcopy(docs_te)\n",
    "    thetass = []\n",
    "    wss = []\n",
    "    total_words = 0\n",
    "    for wix in wixs:\n",
    "        ws = docs_te[:, wix].ravel()\n",
    "        if 0 < ws.sum():\n",
    "            # Hold-out\n",
    "            docs_[:, wix] = 0\n",
    "\n",
    "            # Topic distributions\n",
    "            thetas = transform(docs_)\n",
    "\n",
    "            # Predictive log probability\n",
    "            lpss.append(calc_pp(ws, thetas, beta, wix))\n",
    "\n",
    "            docs_[:, wix] = ws\n",
    "            thetass.append(thetas)\n",
    "            wss.append(ws)\n",
    "            total_words += ws.sum()\n",
    "        else:\n",
    "            thetass.append(None)\n",
    "            wss.append(None)\n",
    "\n",
    "    # Log-probability\n",
    "    lp = np.sum(np.hstack(lpss)) / total_words\n",
    "\n",
    "    return {\"lp\": lp, \"thetass\": thetass, \"beta\": beta, \"wss\": wss}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`transform()` function is defined with `sample_vp()` function. This function is an argument to the function for calculating log predictive probabilities. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "inp = tt.matrix(dtype=\"int64\")\n",
    "sample_vi_theta = theano.function(\n",
    "    [inp], approx.sample_node(approx.model.theta, 100, more_replacements={doc_t: inp}).mean(0)\n",
    ")\n",
    "\n",
    "\n",
    "def transform_pymc3(docs):\n",
    "    return sample_vi_theta(docs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 7min 46s, sys: 7min 17s, total: 15min 3s\n",
      "Wall time: 36 s\n",
      "Predictive log prob (pm3) = -6.213144040486087\n"
     ]
    }
   ],
   "source": [
    "%time result_pymc3 = eval_lda(\\\n",
    "          transform_pymc3, beta_pymc3, docs_te.toarray(), np.arange(100)\\\n",
    "      )\n",
    "print(\"Predictive log prob (pm3) = {}\".format(result_pymc3[\"lp\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We compare the result with the scikit-learn LDA implemented. The log predictive probability is comparable with AEVB-ADVI, and it shows good set of words in the estimated topics."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 3min 44s, sys: 4min 4s, total: 7min 49s\n",
      "Wall time: 1min 23s\n",
      "Predictive log prob (sklearn) = -6.014771065227894\n"
     ]
    }
   ],
   "source": [
    "def transform_sklearn(docs):\n",
    "    thetas = lda.transform(docs)\n",
    "    return thetas / thetas.sum(axis=1)[:, np.newaxis]\n",
    "\n",
    "\n",
    "%time result_sklearn = eval_lda(\\\n",
    "          transform_sklearn, beta_sklearn, docs_te.toarray(), np.arange(100)\\\n",
    "      )\n",
    "print(\"Predictive log prob (sklearn) = {}\".format(result_sklearn[\"lp\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary\n",
    "We have seen that PyMC3 allows us to estimate random variables of LDA, a probabilistic model with latent variables, based on automatic variational inference. Variational parameters of the local latent variables in the probabilistic model are encoded from observations. The parameters of the encoding model, MLP in this example, are optimized with variational parameters of the global latent variables. Once the probabilistic and the encoding models are defined, parameter optimization is done just by invoking an inference (`ADVI()`) without need to derive complex update equations. \n",
    "\n",
    "This notebook shows that even mean field approximation can perform as well as sklearn implementation, which is based on the conjugate priors and thus not relying on the mean field approximation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## References\n",
    "* Kingma, D. P., & Welling, M. (2014). Auto-Encoding Variational Bayes. stat, 1050, 1.\n",
    "* Kucukelbir, A., Ranganath, R., Gelman, A., & Blei, D. (2015). Automatic variational inference in Stan. In Advances in neural information processing systems (pp. 568-576).\n",
    "* Blei, D. M., Ng, A. Y., & Jordan, M. I. (2003). Latent dirichlet allocation. Journal of machine Learning research, 3(Jan), 993-1022.\n",
    "* Hoffman, M. D., Blei, D. M., Wang, C., & Paisley, J. W. (2013). Stochastic variational inference. Journal of Machine Learning Research, 14(1), 1303-1347.\n",
    "* Rezende, D. J., & Mohamed, S. (2015). Variational inference with normalizing flows. arXiv preprint arXiv:1505.05770.\n",
    "* Salimans, T., Kingma, D. P., & Welling, M. (2015). Markov chain Monte Carlo and variational inference: Bridging the gap. In International Conference on Machine Learning (pp. 1218-1226)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "theano  1.0.5\n",
      "seaborn 0.11.0\n",
      "numpy   1.17.3\n",
      "pymc3   3.9.3\n",
      "last updated: Sat Sep 26 2020 \n",
      "\n",
      "CPython 3.7.8\n",
      "IPython 7.17.0\n",
      "watermark 2.0.2\n"
     ]
    }
   ],
   "source": [
    "%load_ext watermark\n",
    "%watermark -n -u -v -iv -w"
   ]
  }
 ],
 "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.8"
  },
  "latex_envs": {
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 0
  },
  "nav_menu": {},
  "toc": {
   "navigate_menu": true,
   "number_sections": true,
   "sideBar": true,
   "threshold": 6,
   "toc_cell": false,
   "toc_section_display": "block",
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}