{ "cells": [ { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "6oXxxX9LZL-h" }, "source": [ "# Dirichlet Process Mixture Models in Pyro\n", "\n", "\n", "## What are Bayesian nonparametric models?\n", "Bayesian nonparametric models are models where the number of parameters grow freely with the amount of data provided; thus, instead of training several models that vary in complexity and comparing them, one is able to design a model whose complexity grows as more data are observed. The prototypical example of Bayesian nonparametrics in practice is the *Dirichlet Process Mixture Model* (DPMM). A DPMM allows for a practitioner to build a mixture model when the number of distinct clusters in the geometric structure of their data is unknown – in other words, the number of clusters is allowed to grow as more data is observed. This feature makes the DPMM highly useful towards exploratory data analysis, where few facets of the data in question are known; this presentation aims to demonstrate this fact.\n", "\n", "## The Dirichlet Process (Ferguson, 1973)\n", "Dirichlet processes are a family of probability distributions over discrete probability distributions. Formally, the Dirichlet process (DP) is specified by some base probability distribution $G_0: \\Omega \\to \\mathbb{R}$ and a positive, real, scaling parameter commonly denoted as $\\alpha$. A sample $G$ from a Dirichlet process with parameters $G_0: \\Omega \\to \\mathbb{R}$ and $\\alpha$ is itself a distribution over $\\Omega$. For any disjoint partition $\\Omega_1, ..., \\Omega_k$ of $\\Omega$, and any sample $G \\sim DP(G_0, \\alpha)$, we have:\n", "\n", "$$(G(\\Omega_1), ..., G(\\Omega_k)) \\sim \\text{Dir}(\\alpha G_0(\\Omega_1), ..., \\alpha G_0(\\Omega_k))$$\n", "\n", "Essentially, this is taking a discrete partition of our sample space $\\Omega$ and subsequently constructing a discrete distribution over it using the base distribution $G_0$. While quite abstract in formulation, the Dirichlet process is very useful as a prior in various graphical models. This fact becomes easier to see in the following scheme.\n", "\n", "## The Chinese Restaurant Process (Aldous, 1985)\n", "\n", "Imagine a restaurant with infinite tables (indexed by the positive integers) that accepts customers one at a time. The $n$th customer chooses their seat according to the following probabilities:\n", "\n", "* With probability $\\frac{n_t}{\\alpha + n - 1}$, sit at table $t$, where $n_t$ is the number of people at table $t$\n", "* With probability $\\frac{\\alpha}{\\alpha + n - 1}$, sit at an empty table\n", "\n", "If we associate to each table $t$ a draw from a base distribution $G_0$ over $\\Omega$, and then associate unnormalized probability mass $n_t$ to that draw, the resulting distribution over $\\Omega$ is equivalent to a draw from a Dirichlet process $DP(G_0, \\alpha)$. \n", "\n", "Furthermore, we can easily extend this to define the generative process of a nonparametric mixture model: every table $t$ that has at least one customer seated is associated with a set of cluster parameters $\\theta_t$, which were themselves drawn from some base distribution $G_0$. For each new observation, first assign that observation to a table according to the above probabilities; then, that observation is drawn from the distribution parameterized by the cluster parameters for that table. If the observation was assigned to a new table, draw a new set of cluster parameters from $G_0$, and then draw the observation from the distribution parameterized by those cluster parameters.\n", "\n", "While this formulation of a Dirichlet process mixture model is intuitive, it is also very difficult to perform inference on in a probabilistic programming framework. This motivates an alternative formulation of DPMMs, which has empirically been shown to be more conducive to inference (e.g. Blei and Jordan, 2004).\n", "\n", "## The Stick-Breaking Method (Sethuraman, 1994)\n", "\n", "The generative process for the stick-breaking formulation of DPMMs proceeds as follows:\n", "\n", "* Draw $\\beta_i \\sim \\text{Beta}(1, \\alpha)$ for $i \\in \\mathbb{N}$\n", "* Draw $\\theta_i \\sim G_0$ for $i \\in \\mathbb{N}$\n", "* Construct the mixture weights $\\pi$ by taking $\\pi_i(\\beta_{1:\\infty}) = \\beta_i \\prod_{j" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "data = torch.cat((MultivariateNormal(-8 * torch.ones(2), torch.eye(2)).sample([50]),\n", " MultivariateNormal(8 * torch.ones(2), torch.eye(2)).sample([50]),\n", " MultivariateNormal(torch.tensor([1.5, 2]), torch.eye(2)).sample([50]),\n", " MultivariateNormal(torch.tensor([-0.5, 1]), torch.eye(2)).sample([50])))\n", "\n", "plt.scatter(data[:, 0], data[:, 1])\n", "plt.title(\"Data Samples from Mixture of 4 Gaussians\")\n", "plt.show()\n", "N = data.shape[0]" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "CglLQke4gEYd" }, "source": [ "In this example, the cluster parameters$\\theta_i$are two dimensional vectors describing the means of a multivariate Gaussian with identity covariance. Therefore, the Dirichlet process base distribution$G_0$is also a multivariate Gaussian (i.e. the conjugate prior), although this choice is not as computationally useful, since we are not performing coordinate-ascent variational inference but rather black-box variational inference using Pyro. \n", "\n", "First, let's define the \"stick-breaking\" function that generates our weights, given our samples of$\\beta$:" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "colab": {}, "colab_type": "code", "id": "2ngrqFlDQYpV" }, "outputs": [], "source": [ "def mix_weights(beta):\n", " beta1m_cumprod = (1 - beta).cumprod(-1)\n", " return F.pad(beta, (0, 1), value=1) * F.pad(beta1m_cumprod, (1, 0), value=1)" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "LAC0bWL6Qcc3" }, "source": [ "Next, let's define our model. It may be helpful to refer the definition of the stick-breaking model presented in the first part of this tutorial. \n", "\n", "Note that all$\\beta_i$samples are conditionally independent, so we model them using a pyro.plate of size T-1; we do the same for all samples of our cluster parameters$\\mu_i$. We then construct a Categorical distribution whose parameters are the mixture weights using our sampled$\\beta$values (line 9) below, and sample the cluster assignment$z_n$for each data point from that Categorical. Finally, we sample our observations from a multivariate Gaussian distribution whose mean is exactly the cluster parameter corresponding to the assignment$z_n$we drew for the point$x_n$. This can be seen in the Pyro code below:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "colab": {}, "colab_type": "code", "id": "WfnbSIocRlvQ" }, "outputs": [], "source": [ "def model(data):\n", " with pyro.plate(\"beta_plate\", T-1):\n", " beta = pyro.sample(\"beta\", Beta(1, alpha))\n", "\n", " with pyro.plate(\"mu_plate\", T):\n", " mu = pyro.sample(\"mu\", MultivariateNormal(torch.zeros(2), 5 * torch.eye(2)))\n", "\n", " with pyro.plate(\"data\", N):\n", " z = pyro.sample(\"z\", Categorical(mix_weights(beta)))\n", " pyro.sample(\"obs\", MultivariateNormal(mu[z], torch.eye(2)), obs=data)" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "1gBQj5RKRn8Z" }, "source": [ "Now, it's time to define our guide and perform inference. \n", "\n", "The variational family$q(\\beta, \\theta, z)$that we are optimizing over during variational inference is given by:\n", "\n", "$$q(\\beta, \\theta, z) = \\prod_{t=1}^{T-1} q_t(\\beta_t) \\prod_{t=1}^T q_t(\\theta_t) \\prod_{n=1}^N q_n(z_n)$$ \n", "\n", "Note that since we are unable to computationally model the infinite clusters posited by the model, we truncate our variational family at$T$clusters. This does not affect our model; rather, it is a simplification made in the *inference* stage to allow tractability. \n", "\n", "The guide is constructed exactly according to the definition of our variational family$q(\\beta, \\theta, z)$above. We have$T-1$conditionally independent Beta distributions for each$\\beta$sampled in our model,$T$conditionally independent multivariate Gaussians for each cluster parameter$\\mu_i$, and$N$conditionally independent Categorical distributions for each cluster assignment$z_n$.\n", "\n", "Our variational parameters (pyro.param) are therefore the$T-1$many positive scalars that parameterize the second parameter of our variational Beta distributions (the first shape parameter is fixed at$1$, as in the model definition), the$T$many two-dimensional vectors that parameterize our variational multivariate Gaussian distributions (we do not parameterize the covariance matrices of the Gaussians, though this should be done when analyzing a real-world dataset for more flexibility), and the$N$many$T$-dimensional vectors that parameterize our variational Categorical distributions:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "colab": {}, "colab_type": "code", "id": "Imw4wcVkT9er" }, "outputs": [], "source": [ "def guide(data):\n", " kappa = pyro.param('kappa', lambda: Uniform(0, 2).sample([T-1]), constraint=constraints.positive)\n", " tau = pyro.param('tau', lambda: MultivariateNormal(torch.zeros(2), 3 * torch.eye(2)).sample([T]))\n", " phi = pyro.param('phi', lambda: Dirichlet(1/T * torch.ones(T)).sample([N]), constraint=constraints.simplex)\n", "\n", " with pyro.plate(\"beta_plate\", T-1):\n", " q_beta = pyro.sample(\"beta\", Beta(torch.ones(T-1), kappa))\n", "\n", " with pyro.plate(\"mu_plate\", T):\n", " q_mu = pyro.sample(\"mu\", MultivariateNormal(tau, torch.eye(2)))\n", "\n", " with pyro.plate(\"data\", N):\n", " z = pyro.sample(\"z\", Categorical(phi))" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "H0He1id0T_bN" }, "source": [ "When performing inference, we set our 'guess' for the maximum number of clusters in the dataset to$T = 6\$. We define the optimization algorithm (pyro.optim.Adam) along with the Pyro SVI object and train the model for 1000 iterations. \n", "\n", "After performing inference, we construct the Bayes estimators of the means (the expected values of each factor in our variational approximation) and plot them in red on top of the original dataset. Note that we also have we removed any clusters that have less than a certain weight assigned to them according to our learned variational distributions, and then re-normalize the weights so that they sum to one:" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 372 }, "colab_type": "code", "id": "x1Yidukpd9wO", "outputId": "b0cc290b-3285-4f36-c2a6-7195b6801482" }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "100%|██████████| 1000/1000 [00:15<00:00, 64.86it/s]\n", "100%|██████████| 1000/1000 [00:15<00:00, 65.47it/s]\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "