From 27bc38df061714d803da297886884ab9512ab4b8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Rozet?= Date: Fri, 24 Nov 2023 14:04:24 +0100 Subject: [PATCH 01/15] Update normalizing flow intro --- tutorial/source/index.rst | 2 +- ..._i.ipynb => normalizing_flows_intro.ipynb} | 99 +++++++------------ 2 files changed, 38 insertions(+), 63 deletions(-) rename tutorial/source/{normalizing_flows_i.ipynb => normalizing_flows_intro.ipynb} (99%) diff --git a/tutorial/source/index.rst b/tutorial/source/index.rst index 5d4c0cc12c..368b21f620 100644 --- a/tutorial/source/index.rst +++ b/tutorial/source/index.rst @@ -106,7 +106,7 @@ List of Tutorials vae ss-vae cvae - normalizing_flows_i + normalizing_flows_intro dmm air cevae diff --git a/tutorial/source/normalizing_flows_i.ipynb b/tutorial/source/normalizing_flows_intro.ipynb similarity index 99% rename from tutorial/source/normalizing_flows_i.ipynb rename to tutorial/source/normalizing_flows_intro.ipynb index 87284ba4b4..b56f08ebab 100644 --- a/tutorial/source/normalizing_flows_i.ipynb +++ b/tutorial/source/normalizing_flows_intro.ipynb @@ -4,10 +4,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Normalizing Flows - Introduction (Part 1)\n", + "# Normalizing Flows - Introduction\n", + "\n", + "This tutorial introduces Pyro's built-in normalizing flows. It is independent of most 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", + "> The development of Pyro's built-in flows has stopped in favor of external libraries. We recommend [Zuko](https://zuko.readthedocs.io) as it is compatible with Pyro, implements many flow architectures and is [well documented](https://zuko.readthedocs.io).\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", @@ -25,8 +27,7 @@ " \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", + "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", "\\begin{align}\n", "\\mathbb{E}_{p_X(\\cdot)}\\left[f(X)\\right] &= \\int_{\\text{supp}(X)}f(x)p_X(x)dx\\\\\n", @@ -34,29 +35,22 @@ "&= \\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", + "\\log p_Y(y) & = \\log p_X(g^{-1}(y)) + \\log\\left|\\frac{dx}{dy}\\right| \\\\\n", + "& = \\log p_X(g^{-1}(y)) - \\log\\left|\\frac{dy}{dx}\\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", + "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 a sequence of $L$ transforms $(g_1, g_2, \\ldots, g_L)$ such that $Y = g(X) = g_L \\circ \\cdots g_2 \\circ g_1(X)$, then the log-density of $Y$ is\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", + "\\log p_Y(y) = \\log p_X(y_0) + \\sum^{L}_{l=1} \\log \\left| \\frac{dg^{-1}_{l}(y_l)}{dy_{l}} \\right|\n", "\\end{align}\n", "\n", - "\n", - "where we've defined $y_{(0)}=x$, $y_{(L-1)}=y$ for convenience of notation.\n", + "where $y_{l} = y$ and $y_{l-1} = g^{-1}_l(y_{l})$.\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." ] @@ -71,13 +65,11 @@ "\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:" @@ -122,14 +114,12 @@ "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", + "\\log \\left|\\frac{dg}{dx}\\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:" @@ -183,13 +173,11 @@ "source": [ "Our example uses a single transform. However, we can compose transforms to produce more expressive distributions. For instance, if we apply an affine transformation we can produce the general log-normal distribution,\n", "\n", - "\n", "\\begin{align}\n", "X &\\sim \\mathcal{N}(0,1)\\\\\n", "Y &= \\text{exp}(\\mu+\\sigma X).\n", "\\end{align}\n", "\n", - "\n", "or rather, $Y\\sim\\text{LogNormal}(\\mu,\\sigma^2)$. In Pyro this is accomplished, e.g. for $\\mu=3, \\sigma=0.5$, as follows:" ] }, @@ -282,13 +270,13 @@ "plt.show()\n", "\n", "plt.subplot(1, 2, 1)\n", - "sns.distplot(X[:,0], hist=False, kde=True, \n", + "sns.distplot(X[:,0], hist=False, kde=True,\n", " bins=None,\n", " hist_kws={'edgecolor':'black'},\n", " kde_kws={'linewidth': 2})\n", "plt.title(r'$p(x_1)$')\n", "plt.subplot(1, 2, 2)\n", - "sns.distplot(X[:,1], hist=False, kde=True, \n", + "sns.distplot(X[:,1], hist=False, kde=True,\n", " bins=None,\n", " hist_kws={'edgecolor':'black'},\n", " kde_kws={'linewidth': 2})\n", @@ -356,7 +344,7 @@ " loss.backward()\n", " optimizer.step()\n", " flow_dist.clear_cache()\n", - " \n", + "\n", " if step % 200 == 0:\n", " print('step: {}, loss: {}'.format(step, loss.item()))" ] @@ -407,24 +395,24 @@ "plt.show()\n", "\n", "plt.subplot(1, 2, 1)\n", - "sns.distplot(X[:,0], hist=False, kde=True, \n", + "sns.distplot(X[:,0], hist=False, kde=True,\n", " bins=None,\n", " hist_kws={'edgecolor':'black'},\n", " kde_kws={'linewidth': 2},\n", " label='data')\n", - "sns.distplot(X_flow[:,0], hist=False, kde=True, \n", + "sns.distplot(X_flow[:,0], hist=False, kde=True,\n", " bins=None, color='firebrick',\n", " hist_kws={'edgecolor':'black'},\n", " kde_kws={'linewidth': 2},\n", " label='flow')\n", "plt.title(r'$p(x_1)$')\n", "plt.subplot(1, 2, 2)\n", - "sns.distplot(X[:,1], hist=False, kde=True, \n", + "sns.distplot(X[:,1], hist=False, kde=True,\n", " bins=None,\n", " hist_kws={'edgecolor':'black'},\n", " kde_kws={'linewidth': 2},\n", " label='data')\n", - "sns.distplot(X_flow[:,1], hist=False, kde=True, \n", + "sns.distplot(X_flow[:,1], hist=False, kde=True,\n", " bins=None, color='firebrick',\n", " hist_kws={'edgecolor':'black'},\n", " kde_kws={'linewidth': 2},\n", @@ -452,36 +440,30 @@ "\n", "Sampling $Y$ is again trivial and involves evaluation of the forward pass of $g$. We can score $Y$ using the multivariate substitution rule of integral calculus,\n", "\n", - "\n", "\\begin{align}\n", "\\mathbb{E}_{p_X(\\cdot)}\\left[f(X)\\right] &= \\int_{\\text{supp}(X)}f(\\mathbf{x})p_X(\\mathbf{x})d\\mathbf{x}\\\\\n", - "&= \\int_{\\text{supp}(Y)}f(g^{-1}(\\mathbf{y}))p_X(g^{-1}(\\mathbf{y}))\\det\\left|\\frac{d\\mathbf{x}}{d\\mathbf{y}}\\right|d\\mathbf{y}\\\\\n", + "&= \\int_{\\text{supp}(Y)}f(g^{-1}(\\mathbf{y}))p_X(g^{-1}(\\mathbf{y}))\\left|\\det\\frac{d\\mathbf{x}}{d\\mathbf{y}}\\right|d\\mathbf{y}\\\\\n", "&= \\mathbb{E}_{p_Y(\\cdot)}\\left[f(g^{-1}(Y))\\right],\n", "\\end{align}\n", "\n", - "\n", - "where $d\\mathbf{x}/d\\mathbf{y}$ denotes the Jacobian matrix of $g^{-1}(\\mathbf{y})$. Equating the last two lines we get,\n", - "\n", + "where $\\det \\frac{d\\mathbf{x}}{d\\mathbf{y}}$ denotes the determinant of the Jacobian matrix of $g^{-1}(\\mathbf{y})$. Equating the last two lines we get,\n", "\n", "\\begin{align}\n", - "\\log(p_Y(y)) &= \\log(p_X(g^{-1}(y)))+\\log\\left(\\det\\left|\\frac{d\\mathbf{x}}{d\\mathbf{y}}\\right|\\right)\\\\\n", - "&= \\log(p_X(g^{-1}(y)))-\\log\\left(\\det\\left|\\frac{d\\mathbf{y}}{d\\mathbf{x}}\\right|\\right).\n", + "\\log p_Y(y) &= \\log p_X(g^{-1}(y)) + \\log\\left|\\det\\frac{d\\mathbf{x}}{d\\mathbf{y}}\\right|\\\\\n", + "&= \\log p_X(g^{-1}(y)) - \\log\\left|\\det\\frac{d\\mathbf{y}}{d\\mathbf{x}}\\right|.\n", "\\end{align}\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 volume around $Y$ caused by the transformation. For instance, in $2$-dimensions, the geometric interpretation of the absolute value of the determinant of a Jacobian is that it represents the area of a parallelogram with edges defined by the columns of the Jacobian. In $n$-dimensions, the geometric interpretation of the absolute value of the determinant Jacobian is that is represents the hyper-volume of a parallelepiped with $n$ edges defined by the columns of the Jacobian (see a calculus reference such as \\[7\\] for more details).\n", "\n", - "Similar to the univariate case, 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", + "Similar to the univariate case, we can compose such bijective transformations to produce even more complex distributions. By an inductive argument, if we have a sequence of $L$ transforms $(g_1, g_2, \\ldots, g_L)$ such that $Y = g(X) = g_L \\circ \\cdots g_2 \\circ g_1(X)$, then the log-density of $Y$ is\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", + "\\log p_Y(y) = \\log p_X(y_0) + \\sum^{L}_{l=1} \\log \\left| \\det \\frac{dg^{-1}_{l}(y_l)}{dy_{l}} \\right|\n", "\\end{align}\n", "\n", - "where we've defined $y_{(0)}=x$, $y_{(L-1)}=y$ for convenience of notation.\n", + "where $y_{l} = y$ and $y_{l-1} = g^{-1}_l(y_{l})$.\n", "\n", - "The main challenge is in designing parametrizable multivariate bijections that have closed form expressions for both $g$ and $g^{-1}$, a tractable Jacobian whose calculation scales with $O(D)$ rather than $O(D^3)$, and can express a flexible class of functions." + "The main challenge is in designing parametrizable multivariate bijections that have closed form expressions for both $g$ and $g^{-1}$, a tractable Jacobian determinant whose calculation scales with $O(D)$ rather than $O(D^3)$, and can express a flexible class of functions." ] }, { @@ -571,7 +553,7 @@ " loss.backward()\n", " optimizer.step()\n", " flow_dist.clear_cache()\n", - " \n", + "\n", " if step % 500 == 0:\n", " print('step: {}, loss: {}'.format(step, loss.item()))" ] @@ -613,24 +595,24 @@ "plt.show()\n", "\n", "plt.subplot(1, 2, 1)\n", - "sns.distplot(X[:,0], hist=False, kde=True, \n", + "sns.distplot(X[:,0], hist=False, kde=True,\n", " bins=None,\n", " hist_kws={'edgecolor':'black'},\n", " kde_kws={'linewidth': 2},\n", " label='data')\n", - "sns.distplot(X_flow[:,0], hist=False, kde=True, \n", + "sns.distplot(X_flow[:,0], hist=False, kde=True,\n", " bins=None, color='firebrick',\n", " hist_kws={'edgecolor':'black'},\n", " kde_kws={'linewidth': 2},\n", " label='flow')\n", "plt.title(r'$p(x_1)$')\n", "plt.subplot(1, 2, 2)\n", - "sns.distplot(X[:,1], hist=False, kde=True, \n", + "sns.distplot(X[:,1], hist=False, kde=True,\n", " bins=None,\n", " hist_kws={'edgecolor':'black'},\n", " kde_kws={'linewidth': 2},\n", " label='data')\n", - "sns.distplot(X_flow[:,1], hist=False, kde=True, \n", + "sns.distplot(X_flow[:,1], hist=False, kde=True,\n", " bins=None, color='firebrick',\n", " hist_kws={'edgecolor':'black'},\n", " kde_kws={'linewidth': 2},\n", @@ -799,7 +781,7 @@ " optimizer.step()\n", " dist_x1.clear_cache()\n", " dist_x2_given_x1.clear_cache()\n", - " \n", + "\n", " if step % 500 == 0:\n", " print('step: {}, loss: {}'.format(step, loss.item()))" ] @@ -845,24 +827,24 @@ "plt.show()\n", "\n", "plt.subplot(1, 2, 1)\n", - "sns.distplot(X[:,0], hist=False, kde=True, \n", + "sns.distplot(X[:,0], hist=False, kde=True,\n", " bins=None,\n", " hist_kws={'edgecolor':'black'},\n", " kde_kws={'linewidth': 2},\n", " label='data')\n", - "sns.distplot(X_flow[:,0], hist=False, kde=True, \n", + "sns.distplot(X_flow[:,0], hist=False, kde=True,\n", " bins=None, color='firebrick',\n", " hist_kws={'edgecolor':'black'},\n", " kde_kws={'linewidth': 2},\n", " label='flow')\n", "plt.title(r'$p(x_1)$')\n", "plt.subplot(1, 2, 2)\n", - "sns.distplot(X[:,1], hist=False, kde=True, \n", + "sns.distplot(X[:,1], hist=False, kde=True,\n", " bins=None,\n", " hist_kws={'edgecolor':'black'},\n", " kde_kws={'linewidth': 2},\n", " label='data')\n", - "sns.distplot(X_flow[:,1], hist=False, kde=True, \n", + "sns.distplot(X_flow[:,1], hist=False, kde=True,\n", " bins=None, color='firebrick',\n", " hist_kws={'edgecolor':'black'},\n", " kde_kws={'linewidth': 2},\n", @@ -897,13 +879,6 @@ "9. Laurent Dinh, Jascha Sohl-Dickstein, Samy Bengio. [*Density estimation using Real-NVP*](https://arxiv.org/abs/1605.08803). Conference paper at ICLR 2017.\n", "10. David Ha, Andrew Dai, Quoc V. Le. [*HyperNetworks*](https://arxiv.org/abs/1609.09106). Workshop contribution at ICLR 2017." ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From 17003d7c0221f575466a3268fca19ed7f74e089c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Rozet?= Date: Tue, 5 Dec 2023 20:29:24 +0100 Subject: [PATCH 02/15] Add VAE with normalizing flow tutorial --- tutorial/source/index.rst | 1 + tutorial/source/vae_flow_prior.ipynb | 362 +++++++++++++++++++++++++++ 2 files changed, 363 insertions(+) create mode 100644 tutorial/source/vae_flow_prior.ipynb diff --git a/tutorial/source/index.rst b/tutorial/source/index.rst index 368b21f620..4ca1a4dad6 100644 --- a/tutorial/source/index.rst +++ b/tutorial/source/index.rst @@ -104,6 +104,7 @@ List of Tutorials :name: deep-generative-models vae + vae_flow_prior ss-vae cvae normalizing_flows_intro diff --git a/tutorial/source/vae_flow_prior.ipynb b/tutorial/source/vae_flow_prior.ipynb new file mode 100644 index 0000000000..34ec2d0036 --- /dev/null +++ b/tutorial/source/vae_flow_prior.ipynb @@ -0,0 +1,362 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Variational Autoencoder with a Normalizing Flow prior\n", + "\n", + "Using a normalizing flow as prior for the latent variables instead of the typical standard Gaussian is an easy way to make a variational autoencoder (VAE) more expressive. This notebook demonstrates how to implement a VAE with a normalizing flow as prior for the MNIST dataset. We strongly recommend to read [Pyro's VAE tutorial](vae.ipynb) first." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pyro\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.utils.data as data\n", + "import zuko\n", + "\n", + "from pyro.optim import Adam\n", + "from pyro.infer import SVI, Trace_ELBO\n", + "from torch import Tensor, Size\n", + "from torchvision.datasets import MNIST\n", + "from torchvision.transforms.functional import to_tensor, to_pil_image\n", + "from tqdm import tqdm" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data\n", + "\n", + "The [MNIST](https://wikipedia.org/wiki/MNIST_database) dataset consists of 28 x 28 grayscale images representing handwritten digits (0 to 9)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "trainset = MNIST(root='', download=True, train=True, transform=to_tensor)\n", + "trainloader = data.DataLoader(trainset, batch_size=256, shuffle=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x = [trainset[i][0] for i in range(16)]\n", + "x = torch.cat(x, dim=-1)\n", + "\n", + "to_pil_image(x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Model\n", + "\n", + "As for the [previous tutorial](vae.ipynb), we choose a (diagonal) Gaussian model as encoder $q_\\psi(z | x)$ and a Bernoulli model as decoder $p_\\phi(x | z)$. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "class GaussianEncoder(nn.Module):\n", + " def __init__(self, features: int, latent: int):\n", + " super().__init__()\n", + "\n", + " self.hyper = nn.Sequential(\n", + " nn.Linear(features, 1024),\n", + " nn.ReLU(),\n", + " nn.Linear(1024, 1024),\n", + " nn.ReLU(),\n", + " nn.Linear(1024, 2 * latent),\n", + " )\n", + "\n", + " def forward(self, x: Tensor):\n", + " phi = self.hyper(x)\n", + " mu, log_sigma = phi.chunk(2, dim=-1)\n", + "\n", + " return pyro.distributions.Normal(mu, log_sigma.exp()).to_event(1)\n", + "\n", + "\n", + "class BernoulliDecoder(nn.Module):\n", + " def __init__(self, features: int, latent: int):\n", + " super().__init__()\n", + "\n", + " self.hyper = nn.Sequential(\n", + " nn.Linear(latent, 1024),\n", + " nn.ReLU(),\n", + " nn.Linear(1024, 1024),\n", + " nn.ReLU(),\n", + " nn.Linear(1024, features),\n", + " )\n", + "\n", + " def forward(self, z: Tensor):\n", + " phi = self.hyper(z)\n", + " rho = torch.sigmoid(phi)\n", + "\n", + " return pyro.distributions.Bernoulli(rho).to_event(1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "However, we choose a [masked autoregressive flow](https://arxiv.org/abs/1705.07057) (MAF) as prior $p_\\phi(z)$ instead of the typical standard Gaussian $\\mathcal{N}(0, I)$. Instead of implementing the MAF ourselves, we borrow it from the [Zuko](https://github.com/probabilists/zuko) library. Because Zuko distributions are very similar to Pyro distributions, a thin `Zuko2Pyro` wrapper is sufficient to make Zuko and Pyro 100% compatible." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "VAE(\n", + " (encoder): GaussianEncoder(\n", + " (hyper): Sequential(\n", + " (0): Linear(in_features=784, out_features=1024, bias=True)\n", + " (1): ReLU()\n", + " (2): Linear(in_features=1024, out_features=1024, bias=True)\n", + " (3): ReLU()\n", + " (4): Linear(in_features=1024, out_features=32, bias=True)\n", + " )\n", + " )\n", + " (decoder): BernoulliDecoder(\n", + " (hyper): Sequential(\n", + " (0): Linear(in_features=16, out_features=1024, bias=True)\n", + " (1): ReLU()\n", + " (2): Linear(in_features=1024, out_features=1024, bias=True)\n", + " (3): ReLU()\n", + " (4): Linear(in_features=1024, out_features=784, bias=True)\n", + " )\n", + " )\n", + " (prior): MAF(\n", + " (transform): LazyComposedTransform(\n", + " (0): MaskedAutoregressiveTransform(\n", + " (base): MonotonicAffineTransform()\n", + " (order): [0, 1, 2, 3, 4, ..., 11, 12, 13, 14, 15]\n", + " (hyper): MaskedMLP(\n", + " (0): MaskedLinear(in_features=16, out_features=256, bias=True)\n", + " (1): ReLU()\n", + " (2): MaskedLinear(in_features=256, out_features=256, bias=True)\n", + " (3): ReLU()\n", + " (4): MaskedLinear(in_features=256, out_features=32, bias=True)\n", + " )\n", + " )\n", + " (1): MaskedAutoregressiveTransform(\n", + " (base): MonotonicAffineTransform()\n", + " (order): [15, 14, 13, 12, 11, ..., 4, 3, 2, 1, 0]\n", + " (hyper): MaskedMLP(\n", + " (0): MaskedLinear(in_features=16, out_features=256, bias=True)\n", + " (1): ReLU()\n", + " (2): MaskedLinear(in_features=256, out_features=256, bias=True)\n", + " (3): ReLU()\n", + " (4): MaskedLinear(in_features=256, out_features=32, bias=True)\n", + " )\n", + " )\n", + " (2): MaskedAutoregressiveTransform(\n", + " (base): MonotonicAffineTransform()\n", + " (order): [0, 1, 2, 3, 4, ..., 11, 12, 13, 14, 15]\n", + " (hyper): MaskedMLP(\n", + " (0): MaskedLinear(in_features=16, out_features=256, bias=True)\n", + " (1): ReLU()\n", + " (2): MaskedLinear(in_features=256, out_features=256, bias=True)\n", + " (3): ReLU()\n", + " (4): MaskedLinear(in_features=256, out_features=32, bias=True)\n", + " )\n", + " )\n", + " )\n", + " (base): Unconditional(DiagNormal(loc: torch.Size([16]), scale: torch.Size([16])))\n", + " )\n", + ")" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "class Zuko2Pyro(pyro.distributions.Distribution):\n", + " def __init__(self, dist: zuko.distributions.Distribution):\n", + " self.dist = dist\n", + " self.cache = {}\n", + "\n", + " self.has_rsample = dist.has_rsample\n", + " self.event_shape = dist.event_shape\n", + " self.batch_shape = dist.batch_shape\n", + "\n", + " def sample(self, shape: Size = ()) -> Tensor:\n", + " if hasattr(self.dist, \"rsample_and_log_prob\"): # special method for fast sampling + scoring\n", + " x, self.cache[x] = self.dist.rsample_and_log_prob(shape)\n", + " elif self.has_rsample:\n", + " x = self.dist.rsample(shape)\n", + " else:\n", + " x = self.dist.sample(shape)\n", + "\n", + " return x\n", + "\n", + " def log_prob(self, x: Tensor) -> Tensor:\n", + " if x in self.cache:\n", + " return self.cache[x]\n", + " else:\n", + " return self.dist.log_prob(x)\n", + "\n", + " def expand(self, *args, **kwargs):\n", + " return Zuko2Pyro(self.dist.expand(*args, **kwargs))\n", + "\n", + "\n", + "class VAE(nn.Module):\n", + " def __init__(self, features: int, latent: int = 16):\n", + " super().__init__()\n", + "\n", + " self.encoder = GaussianEncoder(features, latent)\n", + " self.decoder = BernoulliDecoder(features, latent)\n", + "\n", + " self.prior = zuko.flows.MAF(\n", + " features=latent,\n", + " transforms=3,\n", + " hidden_features=(256, 256),\n", + " )\n", + "\n", + " def model(self, x: Tensor):\n", + " pyro.module(\"prior\", self.prior)\n", + " pyro.module(\"decoder\", self.decoder)\n", + "\n", + " with pyro.plate(\"batch\", len(x)):\n", + " z = pyro.sample(\"z\", Zuko2Pyro(self.prior()))\n", + " x = pyro.sample(\"x\", self.decoder(z), obs=x)\n", + "\n", + " def guide(self, x: Tensor):\n", + " pyro.module(\"encoder\", self.encoder)\n", + "\n", + " with pyro.plate(\"batch\", len(x)):\n", + " z = pyro.sample(\"z\", self.encoder(x))\n", + "\n", + "vae = VAE(784, 16).cuda()\n", + "vae" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Training\n", + "\n", + "We train our VAE with a standard stochastic variational inference (SVI) pipeline." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 96/96 [24:04<00:00, 15.05s/it, loss=63.1]\n" + ] + } + ], + "source": [ + "pyro.clear_param_store()\n", + "\n", + "svi = SVI(vae.model, vae.guide, Adam({'lr': 1e-3}), loss=Trace_ELBO())\n", + "\n", + "for epoch in (bar := tqdm(range(96))):\n", + " losses = []\n", + "\n", + " for x, _ in trainloader:\n", + " x = x.round().flatten(-3).cuda()\n", + "\n", + " losses.append(svi.step(x))\n", + "\n", + " losses = torch.tensor(losses)\n", + "\n", + " bar.set_postfix(loss=losses.sum().item() / len(trainset))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After training, we can generate MNIST images by sampling latent variables from the prior and decoding them." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "z = vae.prior().sample((16,))\n", + "x = vae.decoder(z).mean.reshape(-1, 28, 28)\n", + "\n", + "to_pil_image(x.movedim(0, 1).reshape(28, -1))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pyro", + "language": "python", + "name": "pyro" + }, + "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.9.18" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From c70b028e46a10243b495fecb4e07c155e5f2079c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Rozet?= Date: Tue, 5 Dec 2023 23:51:19 +0100 Subject: [PATCH 03/15] Add SVI with normalizing flow tutorial --- tutorial/source/index.rst | 1 + tutorial/source/svi_flow_guide.ipynb | 263 +++++++++++++++++++++++++++ 2 files changed, 264 insertions(+) create mode 100644 tutorial/source/svi_flow_guide.ipynb diff --git a/tutorial/source/index.rst b/tutorial/source/index.rst index 4ca1a4dad6..ff26ba6383 100644 --- a/tutorial/source/index.rst +++ b/tutorial/source/index.rst @@ -97,6 +97,7 @@ List of Tutorials jit svi_horovod svi_lightning + svi_flow_guide .. toctree:: :maxdepth: 1 diff --git a/tutorial/source/svi_flow_guide.ipynb b/tutorial/source/svi_flow_guide.ipynb new file mode 100644 index 0000000000..a3bed1c956 --- /dev/null +++ b/tutorial/source/svi_flow_guide.ipynb @@ -0,0 +1,263 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# SVI with a Normalizing Flow guide\n", + "\n", + "Thanks to their expressiveness, normalizing flows (see [normalizing flow introduction](normalizing_flows_intro.ipynb)) are great guide candidates for stochastic variational inference (SVI). This notebook demonstrates how to perform amortized SVI with a normalizing flow as guide." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pyro\n", + "import torch\n", + "import zuko # pip install zuko\n", + "\n", + "from corner import corner, overplot_points # pip install corner\n", + "from pyro.optim import ClippedAdam\n", + "from pyro.infer import SVI, Trace_ELBO\n", + "from torch import Tensor, Size" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Model\n", + "\n", + "We define a simple non-linear model $p(x | z)$ with a standard Gaussian prior $p(z)$ over the latent variables $z$." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "prior = pyro.distributions.Normal(torch.zeros(3), torch.ones(3)).to_event(1)\n", + "\n", + "def likelihood(z: Tensor):\n", + " mu = z[..., :2]\n", + " rho = z[..., 2].tanh() * 0.99\n", + "\n", + " cov = 1e-2 * torch.stack([\n", + " torch.ones_like(rho), rho,\n", + " rho, torch.ones_like(rho),\n", + " ], dim=-1).unflatten(-1, (2, 2))\n", + "\n", + " return pyro.distributions.MultivariateNormal(mu, cov)\n", + "\n", + "def model(x: Tensor):\n", + " with pyro.plate(\"batch\", len(x)):\n", + " z = pyro.sample(\"z\", prior)\n", + "\n", + " with pyro.plate(\"obs\", 5):\n", + " pyro.sample(\"x\", likelihood(z), obs=x.transpose(0, 1))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We sample 64 reference latent variables and observations $(z^*, x^*)$. In practice, $z^*$ is unknown, and $x^*$ is your data." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "z_star = prior.sample((64,))\n", + "x_star = likelihood(z_star).sample((5,)).transpose(0, 1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Guide\n", + "\n", + "We define the guide $q_\\phi(z | x)$ with a normalizing flow. We choose a conditional [neural spline flow](https://arxiv.org/abs/1906.04032) borrowed from the the [Zuko](https://zuko.readthedocs.io/) library. Because Zuko distributions are very similar to Pyro distributions, a thin `Zuko2Pyro` wrapper is sufficient to make Zuko and Pyro 100% compatible." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "flow = zuko.flows.NSF(features=3, context=10, transforms=1, hidden_features=(256, 256))\n", + "flow.transform = flow.transform.inv # inverse autoregressive flow (IAF) are fast to sample from\n", + "\n", + "class Zuko2Pyro(pyro.distributions.Distribution):\n", + " def __init__(self, dist: zuko.distributions.Distribution):\n", + " self.dist = dist\n", + " self.cache = {}\n", + "\n", + " self.has_rsample = dist.has_rsample\n", + " self.event_shape = dist.event_shape\n", + " self.batch_shape = dist.batch_shape\n", + "\n", + " def sample(self, shape: Size = ()) -> Tensor:\n", + " if hasattr(self.dist, \"rsample_and_log_prob\"): # special method for fast sampling + scoring\n", + " x, self.cache[x] = self.dist.rsample_and_log_prob(shape)\n", + " elif self.has_rsample:\n", + " x = self.dist.rsample(shape)\n", + " else:\n", + " x = self.dist.sample(shape)\n", + "\n", + " return x\n", + "\n", + " def log_prob(self, x: Tensor) -> Tensor:\n", + " if x in self.cache:\n", + " return self.cache[x]\n", + " else:\n", + " return self.dist.log_prob(x)\n", + "\n", + " def expand(self, *args, **kwargs):\n", + " return Zuko2Pyro(self.dist.expand(*args, **kwargs))\n", + "\n", + "def guide(x: Tensor):\n", + " pyro.module(\"flow\", flow)\n", + "\n", + " with pyro.plate(\"batch\", len(x)): # amortized\n", + " pyro.sample(\"z\", Zuko2Pyro(flow(x.flatten(-2))))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## SVI\n", + "\n", + "We train our guide with a standard stochastic variational inference (SVI) pipeline. We use 16 particles to reduce the variance of the ELBO and clip the norm of the gradients to make training more stable." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(0) 198898.369140625\n", + "(256) -57.38035583496094\n", + "(512) -102.55340576171875\n", + "(768) -32.146331787109375\n", + "(1024) -15.7586669921875\n", + "(1280) -128.15740966796875\n", + "(1536) -140.51507568359375\n", + "(1792) -165.01589965820312\n", + "(2048) -140.96510314941406\n", + "(2304) -134.46273803710938\n", + "(2560) -117.86982727050781\n", + "(2816) -48.248321533203125\n", + "(3072) -28.278717041015625\n", + "(3328) -165.11941528320312\n", + "(3584) -156.54873657226562\n", + "(3840) -85.64607238769531\n", + "(4096) -142.55633544921875\n" + ] + } + ], + "source": [ + "pyro.clear_param_store()\n", + "\n", + "svi = SVI(model, guide, optim=ClippedAdam({\"lr\": 1e-3, \"clip_norm\": 1.0}), loss=Trace_ELBO(num_particles=16, vectorize_particles=True))\n", + "\n", + "for step in range(4096 + 1):\n", + " elbo = svi.step(x_star)\n", + "\n", + " if step % 256 == 0:\n", + " print(f'({step})', elbo)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Posterior predictive" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "z = flow(x_star[0].flatten()).sample((4096,))\n", + "x = likelihood(z).sample()\n", + "\n", + "fig = corner(x.numpy())\n", + "\n", + "overplot_points(fig, x_star[0].numpy())" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "z = flow(x_star[1].flatten()).sample((4096,))\n", + "x = likelihood(z).sample()\n", + "\n", + "fig = corner(x.numpy())\n", + "\n", + "overplot_points(fig, x_star[1].numpy())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pyro", + "language": "python", + "name": "pyro" + }, + "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.9.18" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 1b62c2977a78062d9032c6d86a2891d9a504b454 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Rozet?= Date: Thu, 14 Dec 2023 12:49:19 -0600 Subject: [PATCH 04/15] Move Zuko2Pyro to contrib.zuko --- pyro/contrib/zuko.py | 47 +++++++++++++++++++ tutorial/source/index.rst | 2 +- tutorial/source/normalizing_flows_intro.ipynb | 2 +- tutorial/source/svi_flow_guide.ipynb | 33 ++----------- tutorial/source/vae_flow_prior.ipynb | 34 ++------------ 5 files changed, 55 insertions(+), 63 deletions(-) create mode 100644 pyro/contrib/zuko.py diff --git a/pyro/contrib/zuko.py b/pyro/contrib/zuko.py new file mode 100644 index 0000000000..46ffdb93e7 --- /dev/null +++ b/pyro/contrib/zuko.py @@ -0,0 +1,47 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + +import pyro +import torch + +from torch import Size, Tensor +from typing import * + + +class Zuko2Pyro(pyro.distributions.TorchDistribution): + r"""Wraps a Zuko (or PyTorch) distribution as a Pyro distribution.""" + + def __init__(self, dist: torch.distributions.Distribution): + self.dist = dist + self.cache = {} + + @property + def has_rsample(self) -> bool: + return self.dist.has_rsample + + @property + def event_shape(self) -> Size: + return self.dist.event_shape + + @property + def batch_shape(self) -> Size: + return self.dist.batch_shape + + def __call__(self, shape: Size = ()) -> Tensor: + if hasattr(self.dist, "rsample_and_log_prob"): # special method for fast sampling + scoring + x, self.cache[x] = self.dist.rsample_and_log_prob(shape) + elif self.has_rsample: + x = self.dist.rsample(shape) + else: + x = self.dist.sample(shape) + + return x + + def log_prob(self, x: Tensor) -> Tensor: + if x in self.cache: + return self.cache[x] + else: + return self.dist.log_prob(x) + + def expand(self, *args, **kwargs): + return Zuko2Pyro(self.dist.expand(*args, **kwargs)) diff --git a/tutorial/source/index.rst b/tutorial/source/index.rst index ff26ba6383..442cb74878 100644 --- a/tutorial/source/index.rst +++ b/tutorial/source/index.rst @@ -105,10 +105,10 @@ List of Tutorials :name: deep-generative-models vae - vae_flow_prior ss-vae cvae normalizing_flows_intro + vae_flow_prior dmm air cevae diff --git a/tutorial/source/normalizing_flows_intro.ipynb b/tutorial/source/normalizing_flows_intro.ipynb index b56f08ebab..039ee5d526 100644 --- a/tutorial/source/normalizing_flows_intro.ipynb +++ b/tutorial/source/normalizing_flows_intro.ipynb @@ -8,7 +8,7 @@ "\n", "This tutorial introduces Pyro's built-in normalizing flows. It is independent of most 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", - "> The development of Pyro's built-in flows has stopped in favor of external libraries. We recommend [Zuko](https://zuko.readthedocs.io) as it is compatible with Pyro, implements many flow architectures and is [well documented](https://zuko.readthedocs.io).\n", + "> The development of Pyro's built-in flows has stopped in favor of external libraries, such as [Zuko](https://github.com/probabilists/zuko), [nflows](https://github.com/bayesiains/nflows), [normflows](https://github.com/VincentStimper/normalizing-flows) or [FlowTorch](https://github.com/stefanwebb/flowtorch). Some of these libraries may no longer be actively maintained or may have interfaces that are not directly compatible with Pyro. For example usages of [Zuko](https://github.com/probabilists/zuko) within Pyro, see [svi_flow_guide.ipynb](svi_flow_guide.ipynb) and [vae_flow_prior.ipynb](vae_flow_prior.ipynb).\n", "\n", "## Introduction\n", "\n", diff --git a/tutorial/source/svi_flow_guide.ipynb b/tutorial/source/svi_flow_guide.ipynb index a3bed1c956..43ef716553 100644 --- a/tutorial/source/svi_flow_guide.ipynb +++ b/tutorial/source/svi_flow_guide.ipynb @@ -20,9 +20,10 @@ "import zuko # pip install zuko\n", "\n", "from corner import corner, overplot_points # pip install corner\n", + "from pyro.contrib.zuko import Zuko2Pyro\n", "from pyro.optim import ClippedAdam\n", "from pyro.infer import SVI, Trace_ELBO\n", - "from torch import Tensor, Size" + "from torch import Tensor" ] }, { @@ -84,7 +85,7 @@ "source": [ "## Guide\n", "\n", - "We define the guide $q_\\phi(z | x)$ with a normalizing flow. We choose a conditional [neural spline flow](https://arxiv.org/abs/1906.04032) borrowed from the the [Zuko](https://zuko.readthedocs.io/) library. Because Zuko distributions are very similar to Pyro distributions, a thin `Zuko2Pyro` wrapper is sufficient to make Zuko and Pyro 100% compatible." + "We define the guide $q_\\phi(z | x)$ with a normalizing flow. We choose a conditional [neural spline flow](https://arxiv.org/abs/1906.04032) borrowed from the the [Zuko](https://zuko.readthedocs.io/) library. Because Zuko distributions are very similar to Pyro distributions, a thin wrapper (`Zuko2Pyro`) is sufficient to make Zuko and Pyro 100% compatible." ] }, { @@ -96,34 +97,6 @@ "flow = zuko.flows.NSF(features=3, context=10, transforms=1, hidden_features=(256, 256))\n", "flow.transform = flow.transform.inv # inverse autoregressive flow (IAF) are fast to sample from\n", "\n", - "class Zuko2Pyro(pyro.distributions.Distribution):\n", - " def __init__(self, dist: zuko.distributions.Distribution):\n", - " self.dist = dist\n", - " self.cache = {}\n", - "\n", - " self.has_rsample = dist.has_rsample\n", - " self.event_shape = dist.event_shape\n", - " self.batch_shape = dist.batch_shape\n", - "\n", - " def sample(self, shape: Size = ()) -> Tensor:\n", - " if hasattr(self.dist, \"rsample_and_log_prob\"): # special method for fast sampling + scoring\n", - " x, self.cache[x] = self.dist.rsample_and_log_prob(shape)\n", - " elif self.has_rsample:\n", - " x = self.dist.rsample(shape)\n", - " else:\n", - " x = self.dist.sample(shape)\n", - "\n", - " return x\n", - "\n", - " def log_prob(self, x: Tensor) -> Tensor:\n", - " if x in self.cache:\n", - " return self.cache[x]\n", - " else:\n", - " return self.dist.log_prob(x)\n", - "\n", - " def expand(self, *args, **kwargs):\n", - " return Zuko2Pyro(self.dist.expand(*args, **kwargs))\n", - "\n", "def guide(x: Tensor):\n", " pyro.module(\"flow\", flow)\n", "\n", diff --git a/tutorial/source/vae_flow_prior.ipynb b/tutorial/source/vae_flow_prior.ipynb index 34ec2d0036..6f75b995d2 100644 --- a/tutorial/source/vae_flow_prior.ipynb +++ b/tutorial/source/vae_flow_prior.ipynb @@ -21,9 +21,10 @@ "import torch.utils.data as data\n", "import zuko\n", "\n", + "from pyro.contrib.zuko import Zuko2Pyro\n", "from pyro.optim import Adam\n", "from pyro.infer import SVI, Trace_ELBO\n", - "from torch import Tensor, Size\n", + "from torch import Tensor\n", "from torchvision.datasets import MNIST\n", "from torchvision.transforms.functional import to_tensor, to_pil_image\n", "from tqdm import tqdm" @@ -129,7 +130,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "However, we choose a [masked autoregressive flow](https://arxiv.org/abs/1705.07057) (MAF) as prior $p_\\phi(z)$ instead of the typical standard Gaussian $\\mathcal{N}(0, I)$. Instead of implementing the MAF ourselves, we borrow it from the [Zuko](https://github.com/probabilists/zuko) library. Because Zuko distributions are very similar to Pyro distributions, a thin `Zuko2Pyro` wrapper is sufficient to make Zuko and Pyro 100% compatible." + "However, we choose a [masked autoregressive flow](https://arxiv.org/abs/1705.07057) (MAF) as prior $p_\\phi(z)$ instead of the typical standard Gaussian $\\mathcal{N}(0, I)$. Instead of implementing the MAF ourselves, we borrow it from the [Zuko](https://github.com/probabilists/zuko) library. Because Zuko distributions are very similar to Pyro distributions, a thin wrapper (`Zuko2Pyro`) is sufficient to make Zuko and Pyro 100% compatible." ] }, { @@ -206,35 +207,6 @@ } ], "source": [ - "class Zuko2Pyro(pyro.distributions.Distribution):\n", - " def __init__(self, dist: zuko.distributions.Distribution):\n", - " self.dist = dist\n", - " self.cache = {}\n", - "\n", - " self.has_rsample = dist.has_rsample\n", - " self.event_shape = dist.event_shape\n", - " self.batch_shape = dist.batch_shape\n", - "\n", - " def sample(self, shape: Size = ()) -> Tensor:\n", - " if hasattr(self.dist, \"rsample_and_log_prob\"): # special method for fast sampling + scoring\n", - " x, self.cache[x] = self.dist.rsample_and_log_prob(shape)\n", - " elif self.has_rsample:\n", - " x = self.dist.rsample(shape)\n", - " else:\n", - " x = self.dist.sample(shape)\n", - "\n", - " return x\n", - "\n", - " def log_prob(self, x: Tensor) -> Tensor:\n", - " if x in self.cache:\n", - " return self.cache[x]\n", - " else:\n", - " return self.dist.log_prob(x)\n", - "\n", - " def expand(self, *args, **kwargs):\n", - " return Zuko2Pyro(self.dist.expand(*args, **kwargs))\n", - "\n", - "\n", "class VAE(nn.Module):\n", " def __init__(self, features: int, latent: int = 16):\n", " super().__init__()\n", From c04675a9cea281eb10b5849f813d2b952f552f89 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Rozet?= Date: Sun, 17 Dec 2023 11:15:23 -0600 Subject: [PATCH 05/15] Drop unmaintained disclaimer --- tutorial/source/normalizing_flows_intro.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tutorial/source/normalizing_flows_intro.ipynb b/tutorial/source/normalizing_flows_intro.ipynb index 039ee5d526..ecbf646bd1 100644 --- a/tutorial/source/normalizing_flows_intro.ipynb +++ b/tutorial/source/normalizing_flows_intro.ipynb @@ -8,7 +8,7 @@ "\n", "This tutorial introduces Pyro's built-in normalizing flows. It is independent of most 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", - "> The development of Pyro's built-in flows has stopped in favor of external libraries, such as [Zuko](https://github.com/probabilists/zuko), [nflows](https://github.com/bayesiains/nflows), [normflows](https://github.com/VincentStimper/normalizing-flows) or [FlowTorch](https://github.com/stefanwebb/flowtorch). Some of these libraries may no longer be actively maintained or may have interfaces that are not directly compatible with Pyro. For example usages of [Zuko](https://github.com/probabilists/zuko) within Pyro, see [svi_flow_guide.ipynb](svi_flow_guide.ipynb) and [vae_flow_prior.ipynb](vae_flow_prior.ipynb).\n", + "> The development of Pyro's built-in flows has stopped in favor of external libraries, such as [Zuko](https://github.com/probabilists/zuko), [nflows](https://github.com/bayesiains/nflows), [normflows](https://github.com/VincentStimper/normalizing-flows) or [FlowTorch](https://github.com/stefanwebb/flowtorch). Some of these libraries may have interfaces that are not directly compatible with Pyro. See the [SVI with flow guide](svi_flow_guide.ipynb) and [VAE with flow prior](vae_flow_prior.ipynb) tutorials for example usages of [Zuko](https://github.com/probabilists/zuko) within Pyro.\n", "\n", "## Introduction\n", "\n", From 492af35b5cd386768e40ed4fb167befc4ffb666d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Rozet?= Date: Sun, 17 Dec 2023 20:57:40 -0600 Subject: [PATCH 06/15] Add Zuko2Pyro test --- tests/contrib/test_zuko.py | 56 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 56 insertions(+) create mode 100644 tests/contrib/test_zuko.py diff --git a/tests/contrib/test_zuko.py b/tests/contrib/test_zuko.py new file mode 100644 index 0000000000..501208384a --- /dev/null +++ b/tests/contrib/test_zuko.py @@ -0,0 +1,56 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + + +import pytest +import pyro +import torch + +from pyro.contrib.zuko import Zuko2Pyro +from pyro.optim import Adam +from pyro.infer import SVI, Trace_ELBO + + +@pytest.mark.parametrize("multivariate", [True, False]) +def test_Zuko2Pyro(multivariate: bool): + # Distribution + if multivariate: + normal = torch.distributions.MultivariateNormal + mu = torch.zeros(3) + sigma = torch.eye(3) + else: + normal = torch.distributions.Normal + mu = torch.zeros(()) + sigma = torch.ones(()) + + dist = normal(mu, sigma) + + # Sample + x1 = pyro.sample("x1", Zuko2Pyro(dist)) + + assert x1.shape == dist.event_shape + + # Sample within plate + with pyro.plate("data", 4): + x2 = pyro.sample("x2", Zuko2Pyro(dist)) + + assert x2.shape == (4, *dist.event_shape) + + # SVI + def model(): + pyro.sample("a", Zuko2Pyro(dist)) + + with pyro.plate("data", 4): + pyro.sample("b", Zuko2Pyro(dist)) + + def guide(): + mu_ = pyro.param("mu", mu) + sigma_ = pyro.param("sigma", sigma) + + pyro.sample("a", Zuko2Pyro(normal(mu_, sigma_))) + + with pyro.plate("data", 4): + pyro.sample("b", Zuko2Pyro(normal(mu_, sigma_))) + + svi = SVI(model, guide, optim=Adam({"lr": 1e-3}), loss=Trace_ELBO()) + svi.step() From c8d7e3fe1e6dfeb24f107cddd5040a26843c92b4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Rozet?= Date: Mon, 18 Dec 2023 12:39:13 -0600 Subject: [PATCH 07/15] Fix linting --- pyro/contrib/zuko.py | 1 - 1 file changed, 1 deletion(-) diff --git a/pyro/contrib/zuko.py b/pyro/contrib/zuko.py index 46ffdb93e7..fc9a9f6022 100644 --- a/pyro/contrib/zuko.py +++ b/pyro/contrib/zuko.py @@ -5,7 +5,6 @@ import torch from torch import Size, Tensor -from typing import * class Zuko2Pyro(pyro.distributions.TorchDistribution): From 96cfaf60a3d801f77c35997ec1ab0f1dd88aa899 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Rozet?= Date: Mon, 18 Dec 2023 12:49:40 -0600 Subject: [PATCH 08/15] Sort import block --- pyro/contrib/zuko.py | 4 ++-- tests/contrib/test_zuko.py | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/pyro/contrib/zuko.py b/pyro/contrib/zuko.py index fc9a9f6022..7b17f0bd61 100644 --- a/pyro/contrib/zuko.py +++ b/pyro/contrib/zuko.py @@ -1,11 +1,11 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 -import pyro import torch - from torch import Size, Tensor +import pyro + class Zuko2Pyro(pyro.distributions.TorchDistribution): r"""Wraps a Zuko (or PyTorch) distribution as a Pyro distribution.""" diff --git a/tests/contrib/test_zuko.py b/tests/contrib/test_zuko.py index 501208384a..3a4ccddaa0 100644 --- a/tests/contrib/test_zuko.py +++ b/tests/contrib/test_zuko.py @@ -3,12 +3,12 @@ import pytest -import pyro import torch +import pyro from pyro.contrib.zuko import Zuko2Pyro -from pyro.optim import Adam from pyro.infer import SVI, Trace_ELBO +from pyro.optim import Adam @pytest.mark.parametrize("multivariate", [True, False]) From fc5c5c02ce272c82d709a3c8b8e1b5d73cabb133 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Rozet?= Date: Mon, 18 Dec 2023 12:59:19 -0600 Subject: [PATCH 09/15] Shorten comment --- pyro/contrib/zuko.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyro/contrib/zuko.py b/pyro/contrib/zuko.py index 7b17f0bd61..19cea0de38 100644 --- a/pyro/contrib/zuko.py +++ b/pyro/contrib/zuko.py @@ -27,7 +27,7 @@ def batch_shape(self) -> Size: return self.dist.batch_shape def __call__(self, shape: Size = ()) -> Tensor: - if hasattr(self.dist, "rsample_and_log_prob"): # special method for fast sampling + scoring + if hasattr(self.dist, "rsample_and_log_prob"): # fast sampling + scoring x, self.cache[x] = self.dist.rsample_and_log_prob(shape) elif self.has_rsample: x = self.dist.rsample(shape) From 10e06797fb1021d568d74a939484b0592c86d67a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Rozet?= Date: Thu, 4 Jan 2024 17:08:56 +0100 Subject: [PATCH 10/15] Address PR comments --- docs/source/contrib.zuko.rst | 5 ++ docs/source/index.rst | 1 + pyro/contrib/zuko.py | 21 ++++++++- tutorial/source/normalizing_flows_intro.ipynb | 2 +- tutorial/source/svi_flow_guide.ipynb | 46 ++++++++++--------- tutorial/source/vae_flow_prior.ipynb | 4 +- 6 files changed, 54 insertions(+), 25 deletions(-) create mode 100644 docs/source/contrib.zuko.rst diff --git a/docs/source/contrib.zuko.rst b/docs/source/contrib.zuko.rst new file mode 100644 index 0000000000..c7f2dbe7e1 --- /dev/null +++ b/docs/source/contrib.zuko.rst @@ -0,0 +1,5 @@ +Zuko in Pyro +============ + +.. automodule:: pyro.contrib.zuko + :members: diff --git a/docs/source/index.rst b/docs/source/index.rst index 82b70e684f..a5104fb9bc 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -45,6 +45,7 @@ Pyro Documentation contrib.randomvariable contrib.timeseries contrib.tracking + contrib.zuko Indices and tables diff --git a/pyro/contrib/zuko.py b/pyro/contrib/zuko.py index 19cea0de38..775c2e1b6b 100644 --- a/pyro/contrib/zuko.py +++ b/pyro/contrib/zuko.py @@ -1,6 +1,14 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 +""" +This file contains helpers to use `Zuko `_-based +normalizing flows within Pyro piplines. + +Accompanying tutorials can be found at `tutorial/svi_flow_guide.ipynb` and +`tutorial/vae_flow_prior.ipynb`. +""" + import torch from torch import Size, Tensor @@ -8,7 +16,18 @@ class Zuko2Pyro(pyro.distributions.TorchDistribution): - r"""Wraps a Zuko (or PyTorch) distribution as a Pyro distribution.""" + r"""Wraps a Zuko distribution as a Pyro distribution. + + :param dist: A distribution instance. + :type dist: torch.distributions.Distribution + + Example: + >>> flow = zuko.flows.MAF(features=5) + >>> dist = Zuko2Pyro(flow()) + >>> dist((2, 3)).shape + torch.Size([2, 3, 5]) + >>> x = pyro.sample("x", dist) + """ def __init__(self, dist: torch.distributions.Distribution): self.dist = dist diff --git a/tutorial/source/normalizing_flows_intro.ipynb b/tutorial/source/normalizing_flows_intro.ipynb index ecbf646bd1..3617edc98e 100644 --- a/tutorial/source/normalizing_flows_intro.ipynb +++ b/tutorial/source/normalizing_flows_intro.ipynb @@ -8,7 +8,7 @@ "\n", "This tutorial introduces Pyro's built-in normalizing flows. It is independent of most 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", - "> The development of Pyro's built-in flows has stopped in favor of external libraries, such as [Zuko](https://github.com/probabilists/zuko), [nflows](https://github.com/bayesiains/nflows), [normflows](https://github.com/VincentStimper/normalizing-flows) or [FlowTorch](https://github.com/stefanwebb/flowtorch). Some of these libraries may have interfaces that are not directly compatible with Pyro. See the [SVI with flow guide](svi_flow_guide.ipynb) and [VAE with flow prior](vae_flow_prior.ipynb) tutorials for example usages of [Zuko](https://github.com/probabilists/zuko) within Pyro.\n", + "> The development of Pyro's built-in flows has stopped in favor of external libraries, such as [Zuko](https://github.com/probabilists/zuko), [nflows](https://github.com/bayesiains/nflows), [normflows](https://github.com/VincentStimper/normalizing-flows) or [FlowTorch](https://flowtorch.ai/). Some of these libraries may have interfaces that are not directly compatible with Pyro. See the [SVI with flow guide](svi_flow_guide.ipynb) and [VAE with flow prior](vae_flow_prior.ipynb) tutorials for example usages of [Zuko](https://github.com/probabilists/zuko) within Pyro.\n", "\n", "## Introduction\n", "\n", diff --git a/tutorial/source/svi_flow_guide.ipynb b/tutorial/source/svi_flow_guide.ipynb index 43ef716553..d9406500f5 100644 --- a/tutorial/source/svi_flow_guide.ipynb +++ b/tutorial/source/svi_flow_guide.ipynb @@ -6,7 +6,9 @@ "source": [ "# SVI with a Normalizing Flow guide\n", "\n", - "Thanks to their expressiveness, normalizing flows (see [normalizing flow introduction](normalizing_flows_intro.ipynb)) are great guide candidates for stochastic variational inference (SVI). This notebook demonstrates how to perform amortized SVI with a normalizing flow as guide." + "Thanks to their expressiveness, normalizing flows (see [normalizing flow introduction](normalizing_flows_intro.ipynb)) are great guide candidates for stochastic variational inference (SVI). This notebook demonstrates how to perform amortized SVI with a normalizing flow as guide.\n", + "\n", + "> In this notebook we use [Zuko](https://zuko.readthedocs.io/) to implement normalizing flows, but similar results can be obtained with other PyTorch-based flow libraries." ] }, { @@ -85,7 +87,7 @@ "source": [ "## Guide\n", "\n", - "We define the guide $q_\\phi(z | x)$ with a normalizing flow. We choose a conditional [neural spline flow](https://arxiv.org/abs/1906.04032) borrowed from the the [Zuko](https://zuko.readthedocs.io/) library. Because Zuko distributions are very similar to Pyro distributions, a thin wrapper (`Zuko2Pyro`) is sufficient to make Zuko and Pyro 100% compatible." + "We define the guide $q_\\phi(z | x)$ with a normalizing flow. We choose a conditional [neural spline flow](https://arxiv.org/abs/1906.04032) borrowed from the [Zuko](https://zuko.readthedocs.io/) library. Because Zuko distributions are very similar to Pyro distributions, a thin wrapper (`Zuko2Pyro`) is sufficient to make Zuko and Pyro 100% compatible." ] }, { @@ -122,30 +124,30 @@ "name": "stdout", "output_type": "stream", "text": [ - "(0) 198898.369140625\n", - "(256) -57.38035583496094\n", - "(512) -102.55340576171875\n", - "(768) -32.146331787109375\n", - "(1024) -15.7586669921875\n", - "(1280) -128.15740966796875\n", - "(1536) -140.51507568359375\n", - "(1792) -165.01589965820312\n", - "(2048) -140.96510314941406\n", - "(2304) -134.46273803710938\n", - "(2560) -117.86982727050781\n", - "(2816) -48.248321533203125\n", - "(3072) -28.278717041015625\n", - "(3328) -165.11941528320312\n", - "(3584) -156.54873657226562\n", - "(3840) -85.64607238769531\n", - "(4096) -142.55633544921875\n" + "(0) 143512.64395141602\n", + "(256) -82.79693603515625\n", + "(512) -116.50436401367188\n", + "(768) -135.14303588867188\n", + "(1024) -124.84771728515625\n", + "(1280) -141.2506866455078\n", + "(1536) -147.6421661376953\n", + "(1792) -153.61279296875\n", + "(2048) -143.5320281982422\n", + "(2304) -151.1400146484375\n", + "(2560) -134.08444213867188\n", + "(2816) -147.55593872070312\n", + "(3072) -140.03173828125\n", + "(3328) -146.55886840820312\n", + "(3584) -145.53024291992188\n", + "(3840) -139.77804565429688\n", + "(4096) -145.12144470214844\n" ] } ], "source": [ "pyro.clear_param_store()\n", "\n", - "svi = SVI(model, guide, optim=ClippedAdam({\"lr\": 1e-3, \"clip_norm\": 1.0}), loss=Trace_ELBO(num_particles=16, vectorize_particles=True))\n", + "svi = SVI(model, guide, optim=ClippedAdam({\"lr\": 1e-3, \"clip_norm\": 10.0}), loss=Trace_ELBO(num_particles=16, vectorize_particles=True))\n", "\n", "for step in range(4096 + 1):\n", " elbo = svi.step(x_star)\n", @@ -168,7 +170,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -193,7 +195,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/tutorial/source/vae_flow_prior.ipynb b/tutorial/source/vae_flow_prior.ipynb index 6f75b995d2..a5087811bd 100644 --- a/tutorial/source/vae_flow_prior.ipynb +++ b/tutorial/source/vae_flow_prior.ipynb @@ -6,7 +6,9 @@ "source": [ "# Variational Autoencoder with a Normalizing Flow prior\n", "\n", - "Using a normalizing flow as prior for the latent variables instead of the typical standard Gaussian is an easy way to make a variational autoencoder (VAE) more expressive. This notebook demonstrates how to implement a VAE with a normalizing flow as prior for the MNIST dataset. We strongly recommend to read [Pyro's VAE tutorial](vae.ipynb) first." + "Using a normalizing flow as prior for the latent variables instead of the typical standard Gaussian is an easy way to make a variational autoencoder (VAE) more expressive. This notebook demonstrates how to implement a VAE with a normalizing flow as prior for the MNIST dataset. We strongly recommend to read [Pyro's VAE tutorial](vae.ipynb) first.\n", + "\n", + "> In this notebook we use [Zuko](https://zuko.readthedocs.io/) to implement normalizing flows, but similar results can be obtained with other PyTorch-based flow libraries." ] }, { From 910243c6a0753eeac28e9d74ea23db676678618c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Rozet?= Date: Thu, 4 Jan 2024 17:31:21 +0100 Subject: [PATCH 11/15] Fix doctests --- pyro/contrib/zuko.py | 24 ++++++++++++++++++------ 1 file changed, 18 insertions(+), 6 deletions(-) diff --git a/pyro/contrib/zuko.py b/pyro/contrib/zuko.py index 775c2e1b6b..bca120b2c2 100644 --- a/pyro/contrib/zuko.py +++ b/pyro/contrib/zuko.py @@ -21,12 +21,24 @@ class Zuko2Pyro(pyro.distributions.TorchDistribution): :param dist: A distribution instance. :type dist: torch.distributions.Distribution - Example: - >>> flow = zuko.flows.MAF(features=5) - >>> dist = Zuko2Pyro(flow()) - >>> dist((2, 3)).shape - torch.Size([2, 3, 5]) - >>> x = pyro.sample("x", dist) + .. code-block:: python + + flow = zuko.flows.MAF(features=5) + + # flow() is a torch.distributions.Distribution + + dist = flow() + x = dist.sample((2, 3)) + log_p = dist.log_prob(x) + + # Zuko2Pyro(flow()) is a pyro.distributions.Distribution + + dist = Zuko2Pyro(flow()) + x = dist((2, 3)) + log_p = dist.log_prob(x) + + with pyro.plate("data", 42): + z = pyro.sample("z", dist) """ def __init__(self, dist: torch.distributions.Distribution): From ae105d4e6057de6a2a6665bdd50944f24dd054d9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Rozet?= Date: Sat, 13 Jan 2024 00:24:08 +0100 Subject: [PATCH 12/15] Address PR comments --- pyro/contrib/zuko.py | 12 ++++-- tests/contrib/test_zuko.py | 24 +++++++---- tutorial/source/svi_flow_guide.ipynb | 60 ++++++++++++++-------------- tutorial/source/vae_flow_prior.ipynb | 6 +-- 4 files changed, 57 insertions(+), 45 deletions(-) diff --git a/pyro/contrib/zuko.py b/pyro/contrib/zuko.py index bca120b2c2..232b773389 100644 --- a/pyro/contrib/zuko.py +++ b/pyro/contrib/zuko.py @@ -15,9 +15,13 @@ import pyro -class Zuko2Pyro(pyro.distributions.TorchDistribution): +class ZukoToPyro(pyro.distributions.TorchDistribution): r"""Wraps a Zuko distribution as a Pyro distribution. + If ``dist`` has an ``rsample_and_log_prob`` method, like Zuko's flows, it will be + used when sampling instead of ``rsample``. The returned log density will be cached + for later scoring. + :param dist: A distribution instance. :type dist: torch.distributions.Distribution @@ -31,9 +35,9 @@ class Zuko2Pyro(pyro.distributions.TorchDistribution): x = dist.sample((2, 3)) log_p = dist.log_prob(x) - # Zuko2Pyro(flow()) is a pyro.distributions.Distribution + # ZukoToPyro(flow()) is a pyro.distributions.Distribution - dist = Zuko2Pyro(flow()) + dist = ZukoToPyro(flow()) x = dist((2, 3)) log_p = dist.log_prob(x) @@ -74,4 +78,4 @@ def log_prob(self, x: Tensor) -> Tensor: return self.dist.log_prob(x) def expand(self, *args, **kwargs): - return Zuko2Pyro(self.dist.expand(*args, **kwargs)) + return ZukoToPyro(self.dist.expand(*args, **kwargs)) diff --git a/tests/contrib/test_zuko.py b/tests/contrib/test_zuko.py index 3a4ccddaa0..012dcbad38 100644 --- a/tests/contrib/test_zuko.py +++ b/tests/contrib/test_zuko.py @@ -6,13 +6,14 @@ import torch import pyro -from pyro.contrib.zuko import Zuko2Pyro +from pyro.contrib.zuko import ZukoToPyro from pyro.infer import SVI, Trace_ELBO from pyro.optim import Adam @pytest.mark.parametrize("multivariate", [True, False]) -def test_Zuko2Pyro(multivariate: bool): +@pytest.mark.parametrize("rsample_and_log_prob", [True, False]) +def test_ZukoToPyro(multivariate: bool, rsample_and_log_prob: bool): # Distribution if multivariate: normal = torch.distributions.MultivariateNormal @@ -25,32 +26,39 @@ def test_Zuko2Pyro(multivariate: bool): dist = normal(mu, sigma) + if rsample_and_log_prob: + def dummy(self, shape): + x = self.rsample(x) + return x, self.log_prob(x) + + dist.rsample_and_log_prob = dummy + # Sample - x1 = pyro.sample("x1", Zuko2Pyro(dist)) + x1 = pyro.sample("x1", ZukoToPyro(dist)) assert x1.shape == dist.event_shape # Sample within plate with pyro.plate("data", 4): - x2 = pyro.sample("x2", Zuko2Pyro(dist)) + x2 = pyro.sample("x2", ZukoToPyro(dist)) assert x2.shape == (4, *dist.event_shape) # SVI def model(): - pyro.sample("a", Zuko2Pyro(dist)) + pyro.sample("a", ZukoToPyro(dist)) with pyro.plate("data", 4): - pyro.sample("b", Zuko2Pyro(dist)) + pyro.sample("b", ZukoToPyro(dist)) def guide(): mu_ = pyro.param("mu", mu) sigma_ = pyro.param("sigma", sigma) - pyro.sample("a", Zuko2Pyro(normal(mu_, sigma_))) + pyro.sample("a", ZukoToPyro(normal(mu_, sigma_))) with pyro.plate("data", 4): - pyro.sample("b", Zuko2Pyro(normal(mu_, sigma_))) + pyro.sample("b", ZukoToPyro(normal(mu_, sigma_))) svi = SVI(model, guide, optim=Adam({"lr": 1e-3}), loss=Trace_ELBO()) svi.step() diff --git a/tutorial/source/svi_flow_guide.ipynb b/tutorial/source/svi_flow_guide.ipynb index d9406500f5..4b0fe1c89d 100644 --- a/tutorial/source/svi_flow_guide.ipynb +++ b/tutorial/source/svi_flow_guide.ipynb @@ -22,7 +22,7 @@ "import zuko # pip install zuko\n", "\n", "from corner import corner, overplot_points # pip install corner\n", - "from pyro.contrib.zuko import Zuko2Pyro\n", + "from pyro.contrib.zuko import ZukoToPyro\n", "from pyro.optim import ClippedAdam\n", "from pyro.infer import SVI, Trace_ELBO\n", "from torch import Tensor" @@ -57,11 +57,11 @@ " return pyro.distributions.MultivariateNormal(mu, cov)\n", "\n", "def model(x: Tensor):\n", - " with pyro.plate(\"batch\", len(x)):\n", + " with pyro.plate(\"data\", x.shape[1]):\n", " z = pyro.sample(\"z\", prior)\n", "\n", " with pyro.plate(\"obs\", 5):\n", - " pyro.sample(\"x\", likelihood(z), obs=x.transpose(0, 1))" + " pyro.sample(\"x\", likelihood(z), obs=x)" ] }, { @@ -78,7 +78,7 @@ "outputs": [], "source": [ "z_star = prior.sample((64,))\n", - "x_star = likelihood(z_star).sample((5,)).transpose(0, 1)" + "x_star = likelihood(z_star).sample((5,))" ] }, { @@ -87,7 +87,7 @@ "source": [ "## Guide\n", "\n", - "We define the guide $q_\\phi(z | x)$ with a normalizing flow. We choose a conditional [neural spline flow](https://arxiv.org/abs/1906.04032) borrowed from the [Zuko](https://zuko.readthedocs.io/) library. Because Zuko distributions are very similar to Pyro distributions, a thin wrapper (`Zuko2Pyro`) is sufficient to make Zuko and Pyro 100% compatible." + "We define the guide $q_\\phi(z | x)$ with a normalizing flow. We choose a conditional [neural spline flow](https://arxiv.org/abs/1906.04032) borrowed from the [Zuko](https://zuko.readthedocs.io/) library. Because Zuko distributions are very similar to Pyro distributions, a thin wrapper (`ZukoToPyro`) is sufficient to make Zuko and Pyro 100% compatible." ] }, { @@ -102,8 +102,8 @@ "def guide(x: Tensor):\n", " pyro.module(\"flow\", flow)\n", "\n", - " with pyro.plate(\"batch\", len(x)): # amortized\n", - " pyro.sample(\"z\", Zuko2Pyro(flow(x.flatten(-2))))" + " with pyro.plate(\"data\", x.shape[1]): # amortized\n", + " pyro.sample(\"z\", ZukoToPyro(flow(x.transpose(0, 1).flatten(-2))))" ] }, { @@ -124,23 +124,23 @@ "name": "stdout", "output_type": "stream", "text": [ - "(0) 143512.64395141602\n", - "(256) -82.79693603515625\n", - "(512) -116.50436401367188\n", - "(768) -135.14303588867188\n", - "(1024) -124.84771728515625\n", - "(1280) -141.2506866455078\n", - "(1536) -147.6421661376953\n", - "(1792) -153.61279296875\n", - "(2048) -143.5320281982422\n", - "(2304) -151.1400146484375\n", - "(2560) -134.08444213867188\n", - "(2816) -147.55593872070312\n", - "(3072) -140.03173828125\n", - "(3328) -146.55886840820312\n", - "(3584) -145.53024291992188\n", - "(3840) -139.77804565429688\n", - "(4096) -145.12144470214844\n" + "(0) 209195.08367919922\n", + "(256) -25.225540161132812\n", + "(512) -99.09033203125\n", + "(768) -102.66302490234375\n", + "(1024) -138.8058319091797\n", + "(1280) -92.15625\n", + "(1536) -136.78167724609375\n", + "(1792) -87.76119995117188\n", + "(2048) -116.21714782714844\n", + "(2304) -162.0266571044922\n", + "(2560) -91.13175964355469\n", + "(2816) -164.86270141601562\n", + "(3072) -98.17607116699219\n", + "(3328) -102.58432006835938\n", + "(3584) -151.61912536621094\n", + "(3840) -77.94436645507812\n", + "(4096) -121.82719421386719\n" ] } ], @@ -170,7 +170,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -180,12 +180,12 @@ } ], "source": [ - "z = flow(x_star[0].flatten()).sample((4096,))\n", + "z = flow(x_star[:, 0].flatten()).sample((4096,))\n", "x = likelihood(z).sample()\n", "\n", "fig = corner(x.numpy())\n", "\n", - "overplot_points(fig, x_star[0].numpy())" + "overplot_points(fig, x_star[:, 0].numpy())" ] }, { @@ -195,7 +195,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -205,12 +205,12 @@ } ], "source": [ - "z = flow(x_star[1].flatten()).sample((4096,))\n", + "z = flow(x_star[:, 1].flatten()).sample((4096,))\n", "x = likelihood(z).sample()\n", "\n", "fig = corner(x.numpy())\n", "\n", - "overplot_points(fig, x_star[1].numpy())" + "overplot_points(fig, x_star[:, 1].numpy())" ] } ], diff --git a/tutorial/source/vae_flow_prior.ipynb b/tutorial/source/vae_flow_prior.ipynb index a5087811bd..345a37d94f 100644 --- a/tutorial/source/vae_flow_prior.ipynb +++ b/tutorial/source/vae_flow_prior.ipynb @@ -23,7 +23,7 @@ "import torch.utils.data as data\n", "import zuko\n", "\n", - "from pyro.contrib.zuko import Zuko2Pyro\n", + "from pyro.contrib.zuko import ZukoToPyro\n", "from pyro.optim import Adam\n", "from pyro.infer import SVI, Trace_ELBO\n", "from torch import Tensor\n", @@ -132,7 +132,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "However, we choose a [masked autoregressive flow](https://arxiv.org/abs/1705.07057) (MAF) as prior $p_\\phi(z)$ instead of the typical standard Gaussian $\\mathcal{N}(0, I)$. Instead of implementing the MAF ourselves, we borrow it from the [Zuko](https://github.com/probabilists/zuko) library. Because Zuko distributions are very similar to Pyro distributions, a thin wrapper (`Zuko2Pyro`) is sufficient to make Zuko and Pyro 100% compatible." + "However, we choose a [masked autoregressive flow](https://arxiv.org/abs/1705.07057) (MAF) as prior $p_\\phi(z)$ instead of the typical standard Gaussian $\\mathcal{N}(0, I)$. Instead of implementing the MAF ourselves, we borrow it from the [Zuko](https://github.com/probabilists/zuko) library. Because Zuko distributions are very similar to Pyro distributions, a thin wrapper (`ZukoToPyro`) is sufficient to make Zuko and Pyro 100% compatible." ] }, { @@ -227,7 +227,7 @@ " pyro.module(\"decoder\", self.decoder)\n", "\n", " with pyro.plate(\"batch\", len(x)):\n", - " z = pyro.sample(\"z\", Zuko2Pyro(self.prior()))\n", + " z = pyro.sample(\"z\", ZukoToPyro(self.prior()))\n", " x = pyro.sample(\"x\", self.decoder(z), obs=x)\n", "\n", " def guide(self, x: Tensor):\n", From c7910a4b0ec300effbb839f975f875a57bbcdcb8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Rozet?= Date: Sat, 13 Jan 2024 00:28:34 +0100 Subject: [PATCH 13/15] Fix dummy --- tests/contrib/test_zuko.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/contrib/test_zuko.py b/tests/contrib/test_zuko.py index 012dcbad38..4cc068556f 100644 --- a/tests/contrib/test_zuko.py +++ b/tests/contrib/test_zuko.py @@ -28,7 +28,7 @@ def test_ZukoToPyro(multivariate: bool, rsample_and_log_prob: bool): if rsample_and_log_prob: def dummy(self, shape): - x = self.rsample(x) + x = self.rsample(shape) return x, self.log_prob(x) dist.rsample_and_log_prob = dummy From 7e13090e5a6c6ee87e7906ec85e1073f6bc12a6f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Rozet?= Date: Sat, 13 Jan 2024 00:32:56 +0100 Subject: [PATCH 14/15] Fix weird linting issue --- tests/contrib/test_zuko.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/contrib/test_zuko.py b/tests/contrib/test_zuko.py index 4cc068556f..0e22b898a5 100644 --- a/tests/contrib/test_zuko.py +++ b/tests/contrib/test_zuko.py @@ -27,6 +27,7 @@ def test_ZukoToPyro(multivariate: bool, rsample_and_log_prob: bool): dist = normal(mu, sigma) if rsample_and_log_prob: + def dummy(self, shape): x = self.rsample(shape) return x, self.log_prob(x) From a5a6f59bc10ad9d4d4e9778dc0e416a732e0bb84 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Rozet?= Date: Sat, 13 Jan 2024 11:18:25 +0100 Subject: [PATCH 15/15] Fix dummy (I hope) --- tests/contrib/test_zuko.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/contrib/test_zuko.py b/tests/contrib/test_zuko.py index 0e22b898a5..cee04c177b 100644 --- a/tests/contrib/test_zuko.py +++ b/tests/contrib/test_zuko.py @@ -32,7 +32,7 @@ def dummy(self, shape): x = self.rsample(shape) return x, self.log_prob(x) - dist.rsample_and_log_prob = dummy + dist.rsample_and_log_prob = dummy.__get__(dist) # Sample x1 = pyro.sample("x1", ZukoToPyro(dist))