{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Normalizing Flows - Introduction (Part 1)\n", "\n", "This tutorial introduces Pyro's normalizing flow library. It is independent of much of Pyro, but users may want to read about distribution shapes in the [Tensor Shapes Tutorial](http://pyro.ai/examples/tensor_shapes.html).\n", " \n", "## Introduction\n", "\n", "In standard probabilistic modeling practice, we represent our beliefs over unknown continuous quantities with simple parametric distributions like the normal, exponential, and Laplacian distributions. However, using such simple forms, which are commonly symmetric and unimodal (or have a fixed number of modes when we take a mixture of them), restricts the performance and flexibility of our methods. For instance, standard variational inference in the Variational Autoencoder uses independent univariate normal distributions to represent the variational family. The true posterior is neither independent nor normally distributed, which results in suboptimal inference and simplifies the model that is learnt. In other scenarios, we are likewise restricted by not being able to model multimodal distributions and heavy or light tails.\n", "\n", "Normalizing Flows \$1-4\$ are a family of methods for constructing flexible learnable probability distributions, often with neural networks, which allow us to surpass the limitations of simple parametric forms. Pyro contains state-of-the-art normalizing flow implementations, and this tutorial explains how you can use this library for learning complex models and performing flexible variational inference. We introduce the main idea of Normalizing Flows (NFs) and demonstrate learning simple univariate distributions with element-wise, multivariate, and conditional flows." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Univariate Distributions\n", " \n", "### Background\n", " \n", "Normalizing Flows are a family of methods for constructing flexible distributions. Let's first restrict our attention to representing univariate distributions. The basic idea is that a simple source of noise, for example a variable with a standard normal distribution, $X\\sim\\mathcal{N}(0,1)$, is passed through a bijective (i.e. invertible) function, $g(\\cdot)$ to produce a more complex transformed variable $Y=g(X)$.\n", "\n", "For a given random variable, we typically want to perform two operations: sampling and scoring. Sampling $Y$ is trivial. First, we sample $X=x$, then calculate $y=g(x)$. Scoring $Y$, or rather, evaluating the log-density $\\log(p_Y(y))$, is more involved. How does the density of $Y$ relate to the density of $X$? We can use the substitution rule of integral calculus to answer this. Suppose we want to evaluate the expectation of some function of $X$. Then,\n", "\n", "\n", "\\begin{align}\n", "\\mathbb{E}_{p_X(\\cdot)}\\left[f(X)\\right] &= \\int_{\\text{supp}(X)}f(x)p_X(x)dx\\\\\n", "&= \\int_{\\text{supp}(Y)}f(g^{-1}(y))p_X(g^{-1}(y))\\left|\\frac{dx}{dy}\\right|dy\\\\\n", "&= \\mathbb{E}_{p_Y(\\cdot)}\\left[f(g^{-1}(Y))\\right],\n", "\\end{align}\n", "\n", "\n", "where $\\text{supp}(X)$ denotes the support of $X$, which in this case is $(-\\infty,\\infty)$. Crucially, we used the fact that $g$ is bijective to apply the substitution rule in going from the first to the second line. Equating the last two lines we get,\n", "\n", "\n", "\\begin{align}\n", "\\log(p_Y(y)) &= \\log(p_X(g^{-1}(y)))+\\log\\left(\\left|\\frac{dx}{dy}\\right|\\right)\\\\\n", "&= \\log(p_X(g^{-1}(y)))-\\log\\left(\\left|\\frac{dy}{dx}\\right|\\right).\n", "\\end{align}\n", "\n", "\n", "Inituitively, this equation says that the density of $Y$ is equal to the density at the corresponding point in $X$ plus a term that corrects for the warp in volume around an infinitesimally small length around $Y$ caused by the transformation.\n", "\n", "If $g$ is cleverly constructed (and we will see several examples shortly), we can produce distributions that are more complex than standard normal noise and yet have easy sampling and computationally tractable scoring. Moreover, we can compose such bijective transformations to produce even more complex distributions. By an inductive argument, if we have $L$ transforms $g_{(0)}, g_{(1)},\\ldots,g_{(L-1)}$, then the log-density of the transformed variable $Y=(g_{(0)}\\circ g_{(1)}\\circ\\cdots\\circ g_{(L-1)})(X)$ is\n", "\n", "\n", "\\begin{align}\n", "\\log(p_Y(y)) &= \\log\\left(p_X\\left(\\left(g_{(L-1)}^{-1}\\circ\\cdots\\circ g_{(0)}^{-1}\\right)\\left(y\\right)\\right)\\right)+\\sum^{L-1}_{l=0}\\log\\left(\\left|\\frac{dg^{-1}_{(l)}(y_{(l)})}{dy'}\\right|\\right),\n", "%\\left( g^{(l)}(y^{(l)})\n", "%\\right).\n", "\\end{align}\n", "\n", "\n", "where we've defined $y_{(0)}=x$, $y_{(L-1)}=y$ for convenience of notation.\n", "\n", "In a latter section, we will see how to generalize this method to multivariate $X$. The field of Normalizing Flows aims to construct such $g$ for multivariate $X$ to transform simple i.i.d. standard normal noise into complex, learnable, high-dimensional distributions. The methods have been applied to such diverse applications as image modeling, text-to-speech, unsupervised language induction, data compression, and modeling molecular structures. As probability distributions are the most fundamental component of probabilistic modeling we will likely see many more exciting state-of-the-art applications in the near future." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Fixed Univariate Transforms in Pyro\n", "\n", "PyTorch contains classes for representing *fixed* univariate bijective transformations, and sampling/scoring from transformed distributions derived from these. Pyro extends this with a comprehensive library of *learnable* univariate and multivariate transformations using the latest developments in the field. As Pyro imports all of PyTorch's distributions and transformations, we will work solely with Pyro. We also note that the NF components in Pyro can be used independently of the probabilistic programming functionality of Pyro, which is what we will be doing in the first two tutorials.\n", "\n", "Let us begin by showing how to represent and manipulate a simple transformed distribution,\n", "\n", "\n", "\\begin{align}\n", "X &\\sim \\mathcal{N}(0,1)\\\\\n", "Y &= \\text{exp}(X).\n", "\\end{align}\n", "\n", "\n", "You may have recognized that this is by definition, $Y\\sim\\text{LogNormal}(0,1)$.\n", "\n", "We begin by importing the relevant libraries:" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import torch\n", "import pyro\n", "import pyro.distributions as dist\n", "import pyro.distributions.transforms as T\n", "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", "import os\n", "smoke_test = ('CI' in os.environ)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A variety of bijective transformations live in the [pyro.distributions.transforms](http://docs.pyro.ai/en/stable/distributions.html#transforms) module, and the classes to define transformed distributions live in [pyro.distributions](http://docs.pyro.ai/en/stable/distributions.html). We first create the base distribution of $X$ and the class encapsulating the transform $\\text{exp}(\\cdot)$:" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "dist_x = dist.Normal(torch.zeros(1), torch.ones(1))\n", "exp_transform = T.ExpTransform()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The class [ExpTransform](https://pytorch.org/docs/master/distributions.html#torch.distributions.transforms.ExpTransform) derives from [Transform](https://pytorch.org/docs/master/distributions.html#torch.distributions.transforms.Transform) and defines the forward, inverse, and log-absolute-derivative operations for this transform,\n", "\n", "\n", "\\begin{align}\n", "g(x) &= \\text{exp(x)}\\\\\n", "g^{-1}(y) &= \\log(y)\\\\\n", "\\log\\left(\\left|\\frac{dg}{dx}\\right|\\right) &= x.\n", "\\end{align}\n", "\n", "\n", "In general, a transform class defines these three operations, from which it is sufficient to perform sampling and scoring.\n", "\n", "The class [TransformedDistribution](https://pytorch.org/docs/master/distributions.html#torch.distributions.transformed_distribution.TransformedDistribution) takes a base distribution of simple noise and a list of transforms, and encapsulates the distribution formed by applying these transformations in sequence. We use it as:" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "dist_y = dist.TransformedDistribution(dist_x, [exp_transform])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now, plotting samples from both to verify that we that have produced the log-normal distribution:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "