diff --git a/lampe/inference.py b/lampe/inference.py index f55aa29..641f03a 100644 --- a/lampe/inference.py +++ b/lampe/inference.py @@ -1,5 +1,21 @@ r"""Inference components such as estimators, training losses and MCMC samplers.""" +__all__ = [ + 'NRE', + 'NRELoss', + 'BNRELoss', + 'AMNRE', + 'AMNRELoss', + 'NPE', + 'NPELoss', + 'AMNPE', + 'AMNPELoss', + 'NSE', + 'NSELoss', + 'MetropolisHastings', +] + +import math import torch import torch.nn as nn import torch.nn.functional as F @@ -8,8 +24,9 @@ from torch import Tensor, BoolTensor, Size from typing import * -from zuko.distributions import Distribution, DiagNormal +from zuko.distributions import Distribution, DiagNormal, NormalizingFlow from zuko.flows import FlowModule, MAF +from zuko.transforms import FFJTransform from zuko.utils import broadcast from .nn import MLP @@ -19,20 +36,18 @@ class NRE(nn.Module): r"""Creates a neural ratio estimation (NRE) classifier network. The principle of neural ratio estimation is to train a classifier network - :math:`d_\phi(\theta, x)` to discriminate between pairs :math:`(\theta, x)` - equally sampled from the joint distribution :math:`p(\theta, x)` and the - product of the marginals :math:`p(\theta)p(x)`. Formally, the optimization - problem is + :math:`d_\phi(\theta, x)` to discriminate between pairs :math:`(\theta, x)` equally + sampled from the joint distribution :math:`p(\theta, x)` and the product of the + marginals :math:`p(\theta)p(x)`. Formally, the optimization problem is .. math:: \arg\min_\phi \mathbb{E}_{p(\theta, x)} \big[ \ell(d_\phi(\theta, x)) \big] + \mathbb{E}_{p(\theta)p(x)} \big[ \ell(1 - d_\phi(\theta, x)) \big] - where :math:`\ell(p) = - \log p` is the negative log-likelihood. - For this task, the decision function modeling the Bayes optimal classifier is + where :math:`\ell(p) = -\log p` is the negative log-likelihood. For this task, the + decision function modeling the Bayes optimal classifier is - .. math:: d(\theta, x) - = \frac{p(\theta, x)}{p(\theta, x) + p(\theta) p(x)} + .. math:: d(\theta, x) = \frac{p(\theta, x)}{p(\theta, x) + p(\theta) p(x)} thereby defining the likelihood-to-evidence (LTE) ratio @@ -87,14 +102,14 @@ def forward(self, theta: Tensor, x: Tensor) -> Tensor: class NRELoss(nn.Module): - r"""Creates a module that calculates the loss :math:`l` of a NRE classifier - :math:`d_\phi`. Given a batch of :math:`N` pairs :math:`\{ (\theta_i, x_i) \}`, - the module returns + r"""Creates a module that calculates the cross-entropy loss for a NRE classifier. + + Given a batch of :math:`N` pairs :math:`(\theta_i, x_i)`, the module returns .. math:: l = \frac{1}{N} \sum_{i = 1}^N \ell(d_\phi(\theta_i, x_i)) + \ell(1 - d_\phi(\theta_{i+1}, x_i)) - where :math:`\ell(p) = - \log p` is the negative log-likelihood. + where :math:`\ell(p) = -\log p` is the negative log-likelihood. Arguments: estimator: A classifier network :math:`d_\phi(\theta, x)`. @@ -129,20 +144,18 @@ def forward(self, theta: Tensor, x: Tensor) -> Tensor: class BNRELoss(nn.Module): - r"""Creates a module that calculates the loss :math:`l` of a balanced NRE (BNRE) - classifier :math:`d_\phi`. Given a batch of :math:`N` pairs - :math:`\{ (\theta_i, x_i) \}`, the module returns + r"""Creates a module that calculates the balanced cross-entropy loss for a balanced + NRE (BNRE) classifier. + + Given a batch of :math:`N` pairs :math:`(\theta_i, x_i)`, the module returns .. math:: - \begin{align} - l & = \frac{1}{N} \sum_{i = 1}^N + l & = \frac{1}{N} \sum_{i = 1}^N \ell(d_\phi(\theta_i, x_i)) + \ell(1 - d_\phi(\theta_{i+1}, x_i)) \\ - & + \lambda \left(1 - \frac{1}{N} \sum_{i = 1}^N - d_\phi(\theta_i, x_i) + d_\phi(\theta_{i+1}, x_i) - \right)^2 - \end{align} + & + \lambda \left(1 - \frac{1}{N} \sum_{i = 1}^N + d_\phi(\theta_i, x_i) + d_\phi(\theta_{i+1}, x_i) \right)^2 - where :math:`\ell(p) = - \log p` is the negative log-likelihood. + where :math:`\ell(p) = -\log p` is the negative log-likelihood. References: | Towards Reliable Simulation-Based Inference with Balanced Neural Ratio Estimation (Delaunoy et al., 2022) @@ -191,8 +204,8 @@ class AMNRE(NRE): The principle of AMNRE is to introduce, as input to the classifier, a binary mask :math:`b \in \{0, 1\}^D` indicating a subset of parameters :math:`\theta_b = (\theta_i: b_i = 1)` of interest. Intuitively, this allows the classifier to - distinguish subspaces and to learn a different ratio for each of them. Formally, - the classifier network takes the form :math:`d_\phi(\theta_b, x, b)` and the + distinguish subspaces and to learn a different ratio for each of them. Formally, the + classifier network takes the form :math:`d_\phi(\theta_b, x, b)` and the optimization problem becomes .. math:: \arg\min_\phi @@ -234,7 +247,7 @@ def forward(self, theta: Tensor, x: Tensor, b: BoolTensor) -> Tensor: r""" Arguments: theta: The parameters :math:`\theta`, with shape :math:`(*, D)`, or - a subset :math:`\theta_b`, with shape :math:`(*, |b|)`. + a subset :math:`\theta_b`. x: The observation :math:`x`, with shape :math:`(*, L)`. b: A binary mask :math:`b`, with shape :math:`(*, D)`. @@ -252,9 +265,9 @@ def forward(self, theta: Tensor, x: Tensor, b: BoolTensor) -> Tensor: class AMNRELoss(nn.Module): - r"""Creates a module that calculates the loss :math:`l` of a AMNRE classifier - :math:`d_\phi`. Given a batch of :math:`N` pairs :math:`\{ (\theta_i, x_i) \}`, - the module returns + r"""Creates a module that calculates the cross-entropy loss for an AMNRE classifier. + + Given a batch of :math:`N` pairs :math:`(\theta_i, x_i)`, the module returns .. math:: l = \frac{1}{N} \sum_{i = 1}^N \ell(d_\phi(\theta_i \odot b_i, x_i, b_i)) + @@ -310,15 +323,15 @@ class NPE(nn.Module): distribution :math:`p_\phi(\theta | x)` to approximate the posterior distribution :math:`p(\theta | x)`. The optimization problem is to minimize the expected Kullback-Leibler (KL) divergence between the two distributions for all observations - :math:`x \sim p(x)`, that is + :math:`x \sim p(x)`, that is, .. math:: \arg\min_\phi & ~ \mathbb{E}_{p(x)} - \Big[ \text{KL} \big( p(\theta|x) \parallel p_\phi(\theta | x) \big) \Big] \\ + \Big[ \text{KL} \big( p(\theta|x) \parallel p_\phi(\theta | x) \big) \Big] \\ = \arg\min_\phi & ~ \mathbb{E}_{p(x)} \, \mathbb{E}_{p(\theta | x)} - \left[ \log \frac{p(\theta | x)}{p_\phi(\theta | x)} \right] \\ + \left[ \log \frac{p(\theta | x)}{p_\phi(\theta | x)} \right] \\ = \arg\min_\phi & ~ \mathbb{E}_{p(\theta, x)} - \big[ - \log p_\phi(\theta | x) \big] . + \big[ -\log p_\phi(\theta | x) \big] . Normalizing flows are typically used for :math:`p_\phi(\theta | x)` as they are differentiable parametric distributions enabling gradient-based optimization @@ -375,9 +388,10 @@ def sample(self, x: Tensor, shape: Size = ()) -> Tensor: class NPELoss(nn.Module): - r"""Creates a module that calculates the loss :math:`l` of a NPE normalizing flow - :math:`p_\phi`. Given a batch of :math:`N` pairs :math:`\{ (\theta_i, x_i) \}`, - the module returns + r"""Creates a module that calculates the negative log-likelihood loss for a NPE + normalizing flow. + + Given a batch of :math:`N` pairs :math:`(\theta_i, x_i)`, the module returns .. math:: l = \frac{1}{N} \sum_{i = 1}^N -\log p_\phi(\theta_i | x_i) . @@ -461,9 +475,10 @@ def sample(self, x: Tensor, b: BoolTensor, shape: Size = ()) -> Tensor: class AMNPELoss(nn.Module): - r"""Creates a module that calculates the loss :math:`l` of an AMNPE normalizing flow - :math:`p_\phi`. Given a batch of :math:`N` pairs :math:`\{ (\theta_i, x_i) \}`, - the module returns + r"""Creates a module that calculates the negative log-likelihood loss for an AMNPE + normalizing flow. + + Given a batch of :math:`N` pairs :math:`(\theta_i, x_i)`, the module returns .. math:: l = \frac{1}{N} \sum_{i = 1}^N -\log p_\phi(\theta_i \odot b_i + \theta_{i + 1} \odot (1 - b_i) | x_i, b_i) @@ -505,20 +520,188 @@ def forward(self, theta: Tensor, x: Tensor) -> Tensor: return -log_prob.mean() +class NSE(nn.Module): + r"""Creates a neural score estimation (NSE) regression network. + + The principle of neural score estimation is to train a regression network + :math:`s_\phi(\theta_t, x, t)` to approximate the score :math:`\nabla_{\! \theta_t} + \log p(\theta_t | x)` of the sub-variance preserving (sub-VP) diffusion process + + .. math:: \mathrm{d} \theta_t = -\frac{1}{2} \beta(t) \theta_t \, \mathrm{d} t + + \sqrt{\beta(t) (1 - \alpha(t)^2)} \, \mathrm{d} w + + where :math:`\alpha(t) = \exp(-\int_0^t \beta(u) \, \mathrm{d} u)` and + :math:`\beta(t) = (\beta_\max - \beta_\min) \, t + \beta_\min` . The optimization + problem is to minimize the rescaled score-matching objective, that is, + + .. math:: \arg\min_\phi \mathbb{E}_{p(\theta, x) p(t) p(\theta_t | \theta)} + \Big[ \big\| s_\phi(\theta_t, x, t) - (1 - \alpha(t)) \nabla_{\! \theta_t} + \log p(\theta_t | \theta) \big\|_2^2 \Big] + + where :math:`p(\theta_t | \theta) = \mathcal{N}(\theta_t; \sqrt{\alpha(t)} \, + \theta, (1 - \alpha(t))^2 I)` is the perturbation kernel corresponding to the + diffusion process and for which the optimal regressor is the rescaled score + + .. math:: s(\theta_t, x, t) = + (1 - \alpha(t)) \nabla_{\! \theta_t} \log p(\theta_t | x) . + + Given the latter, or an estimator of the latter, the probability flow ODE + + .. math:: \mathrm{d} \theta_t = + \left[ -\frac{1}{2} \beta(t) \theta_t - \frac{1}{2} \beta(t) (1 + \alpha(t)) + s(\theta_t, x, t) \right] \, \mathrm{d} t + + shares the same marginal densities :math:`p(\theta_t | x)` as the diffusion process + and can be efficiently integrated (forward for log-density computation and backward + for sampling) with black-box ODE solvers. + + References: + | Score-Based Generative Modeling through Stochastic Differential Equations (Song et al., 2021) + | https://arxiv.org/abs/2011.13456 + + Arguments: + theta_dim: The dimensionality :math:`D` of the parameter space. + x_dim: The dimensionality :math:`L` of the observation space. + t_dim: The dimensionality of the time embedding. + build: The network constructor (e.g. :class:`lampe.nn.ResMLP`). + kwargs: Keyword arguments passed to the constructor. + """ + + def __init__( + self, + theta_dim: int, + x_dim: int, + t_dim: int = 1, + build: Callable[[int, int], nn.Module] = MLP, + **kwargs, + ): + super().__init__() + + self.net = build(theta_dim + x_dim + t_dim * 2, theta_dim, **kwargs) + + self.register_buffer('periods', torch.arange(t_dim) + 1) + self.register_buffer('zeros', torch.zeros(theta_dim)) + self.register_buffer('ones', torch.ones(theta_dim)) + + def forward(self, theta: Tensor, x: Tensor, t: Tensor) -> Tensor: + r""" + Arguments: + theta: The parameters :math:`\theta`, with shape :math:`(*, D)`. + x: The observation :math:`x`, with shape :math:`(*, L)`. + t: The time :math:`t`, with shape :math:`(*,).` + + Returns: + The rescaled score :math:`s_\phi(\theta, x, t)`, with shape :math:`(*, D)`. + """ + + t = self.periods * math.pi * t[..., None] + t = torch.cat((t.cos(), t.sin()), dim=-1) + + theta, x, t = broadcast(theta, x, t, ignore=1) + + return self.net(torch.cat((theta, x, t), dim=-1)) + + def alpha(self, t: Tensor) -> Tensor: + return torch.exp(-8.0 * t**2) + + def beta(self, t: Tensor) -> Tensor: + return 16.0 * t + + def ode(self, theta: Tensor, x: Tensor, t: Tensor) -> Tensor: + drift = -self.beta(t) / 2 * theta + diffusion = -self.beta(t) / 2 * (1 + self.alpha(t)) * self.forward(theta, x, t) + + return drift + diffusion + + def flow(self, x: Tensor) -> Distribution: + r""" + Arguments: + x: The observation :math:`x`, with shape :math:`(*, L)`. + + Returns: + The posterior distribution :math:`p_\phi(\theta | x)` induced by the + probability flow ODE. + + Note: + The :func:`log_prob` method of the returned distribution is an unbiased + stochastic estimator of the true log-density. One should average over + a sufficient number of evaluations to attain small errors. + """ + + batch_shape = x.shape[:-1] + + return NormalizingFlow( + transform=FFJTransform( + f=lambda theta, t: self.ode(theta, x, t), + time=x.new_tensor(1.0), + phi=(x, *self.parameters()), + ), + base=DiagNormal(self.zeros, self.ones).expand(batch_shape), + ) + + +class NSELoss(nn.Module): + r"""Creates a module that calculates the rescaled score-matching loss for a NSE + regressor. + + Given a batch of :math:`N` pairs :math:`(\theta_i, x_i)`, the module returns + + .. math:: l = \frac{1}{N} \sum_{i = 1}^N + \| s_\phi(\theta'_i, x_i, t_i) + \varepsilon_i \|_2^2 + + where :math:`t_i \sim \mathcal{U}(0, 1)`, :math:`\varepsilon_i \sim \mathcal{N}(0, + I)` and :math:`\theta'_i = \sqrt{\alpha(t_i)} \, \theta_i + (1 - \alpha(t_i)) \, + \varepsilon_i`. + + Arguments: + estimator: A regression network :math:`s_\phi(\theta, x, t)`. + """ + + def __init__(self, estimator: nn.Module): + super().__init__() + + self.estimator = estimator + + def forward(self, theta: Tensor, x: Tensor) -> Tensor: + r""" + Arguments: + theta: The parameters :math:`\theta`, with shape :math:`(N, D)`. + x: The observation :math:`x`, with shape :math:`(N, L)`. + + Returns: + The scalar loss :math:`l`. + """ + + t = theta.new_empty(theta.shape[:-1]).uniform_(0, 1) + alpha = self.estimator.alpha(t)[..., None] + + epsilon = torch.randn_like(theta) + theta_prime = alpha.sqrt() * theta + (1 - alpha) * epsilon + + score = self.estimator(theta_prime, x, t) + + return (score + epsilon).square().mean() + + class MetropolisHastings(object): r"""Creates a batched Metropolis-Hastings sampler. Metropolis-Hastings is a Markov chain Monte Carlo (MCMC) sampling algorithm used to - sample from intractable distributions :math:`p(x)` whose density is proportional to a - tractable function :math:`f(x)`, with :math:`x \in \mathcal{X}`. The algorithm + sample from intractable distributions :math:`p(x)` whose density is proportional to + a tractable function :math:`f(x)`, with :math:`x \in \mathcal{X}`. The algorithm consists in repeating the following routine for :math:`t = 1` to :math:`T`, where :math:`x_0` is the initial sample and :math:`q(x' | x)` is a pre-defined transition distribution. - 1. sample :math:`x' \sim q(x' | x_{t-1})` - 2. :math:`\displaystyle \alpha \gets \frac{f(x')}{f(x_{t-1})} \frac{q(x_{t-1} | x')}{q(x' | x_{t-1})}` - 3. sample :math:`u \sim \mathcal{U}(0, 1)` - 4. :math:`x_t \gets \begin{cases} x' & \text{if } u \leq \alpha \\ x_{t-1} & \text{otherwise} \end{cases}` + .. math:: + 1. ~ & x' \sim q(x' | x_{t-1}) \\ + 2. ~ & \alpha \gets \frac{f(x')}{f(x_{t-1})} + \frac{q(x_{t-1} | x')}{q(x' | x_{t-1})} \\ + 3. ~ & u \sim \mathcal{U}(0, 1) \\ + 4. ~ & x_t \gets \begin{cases} + x' & \text{if } u \leq \alpha \\ + x_{t-1} & \text{otherwise} + \end{cases} Asymptotically, i.e. when :math:`T \to \infty`, the distribution of samples :math:`x_t` is guaranteed to converge towards :math:`p(x)`. In this implementation, diff --git a/requirements.txt b/requirements.txt index f7631cd..1695fe4 100644 --- a/requirements.txt +++ b/requirements.txt @@ -3,4 +3,4 @@ matplotlib>=3.4.0 numpy>=1.20.0 torch>=1.8.0 tqdm>=4.52.0 -zuko>=0.0.6 +zuko>=0.0.8 diff --git a/sphinx/tutorials.rst b/sphinx/tutorials.rst index 82c1604..f2fb254 100644 --- a/sphinx/tutorials.rst +++ b/sphinx/tutorials.rst @@ -6,5 +6,6 @@ Tutorials 1. Simulators and datasets 2. Neural posterior estimation 3. Neural ratio estimation - 4. Expected coverage - 5. Embedding and GPU + 4. Neural score estimation + 5. Expected coverage + 6. Embedding and GPU diff --git a/tests/test_inference.py b/tests/test_inference.py index e9fd1e5..5e924f8 100644 --- a/tests/test_inference.py +++ b/tests/test_inference.py @@ -186,6 +186,53 @@ def test_AMNPELoss(): assert l.requires_grad +def test_NSE(): + estimator = NSE(3, 5) + + # Non-batched + theta, x, t = randn(3), randn(5), torch.tensor(0.5) + score = estimator(theta, x, t) + + assert score.shape == (3,) + assert score.requires_grad + + # Batched + theta, x, t = randn(256, 3), randn(256, 5), randn(256) + score = estimator(theta, x, t) + + assert score.shape == (256, 3) + + # Mixed + theta, x, t = randn(256, 3), randn(5), randn(1) + score = estimator(theta, x, t) + + assert score.shape == (256, 3) + + # Sample + x = randn(32, 5) + theta = estimator.flow(x).sample((8,)) + + assert theta.shape == (8, 32, 3) + + # Log-density + with torch.no_grad(): + log_p = estimator.flow(x).log_prob(theta) + + assert log_p.shape == (8, 32) + + +def test_NSELoss(): + estimator = NSE(3, 5) + loss = NSELoss(estimator) + + theta, x = randn(256, 3), randn(256, 5) + + l = loss(theta, x) + + assert l.shape == () + assert l.requires_grad + + def test_MetropolisHastings(): log_f = lambda x: -(x**2).sum(dim=-1) / 2 f = lambda x: torch.exp(log_f(x)) diff --git a/tutorials/04_nse.ipynb b/tutorials/04_nse.ipynb new file mode 100644 index 0000000..2c64f0b --- /dev/null +++ b/tutorials/04_nse.ipynb @@ -0,0 +1,277 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Neural score estimation\n", + "\n", + "This tutorial demonstrates how to perform neural score estimation (NSE) with `lampe`." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "import zuko\n", + "\n", + "from itertools import islice\n", + "from tqdm import tqdm\n", + "\n", + "from lampe.data import JointLoader\n", + "from lampe.inference import NSE, NSELoss\n", + "from lampe.plots import nice_rc, corner, mark_point\n", + "from lampe.utils import GDStep" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Simulator" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([ 0.7184, -0.5701, 0.9329])\n", + "tensor([0.1875, 0.5891])\n" + ] + } + ], + "source": [ + "LABELS = [r'$\\theta_1$', r'$\\theta_2$', r'$\\theta_3$']\n", + "LOWER = -torch.ones(3)\n", + "UPPER = torch.ones(3)\n", + "\n", + "prior = zuko.distributions.BoxUniform(LOWER, UPPER)\n", + "\n", + "def simulator(theta: torch.Tensor) -> torch.Tensor:\n", + " x = torch.stack([\n", + " theta[..., 0] + theta[..., 1] * theta[..., 2],\n", + " theta[..., 0] * theta[..., 1] + theta[..., 2],\n", + " ], dim=-1)\n", + "\n", + " return x + 0.05 * torch.randn_like(x)\n", + "\n", + "theta = prior.sample()\n", + "x = simulator(theta)\n", + "\n", + "print(theta, x, sep='\\n')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "loader = JointLoader(prior, simulator, batch_size=128, vectorized=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Training\n", + "\n", + "The principle of neural score estimation (NSE) is to train a regression network $s_\\phi(\\theta, x, t)$ to match the score of a stochastic diffusion process over the parameters $\\theta$. We use the [`NSE`](https://francois-rozet.github.io/lampe/api/inference.html#lampe.inference.NSE) class provided by the [`lampe.inference`](https://francois-rozet.github.io/lampe/api/inference.html) module to create a regression network adapted to the simulator's input and output sizes." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "NSE(\n", + " (net): MLP(\n", + " (0): Linear(in_features=7, out_features=64, bias=True)\n", + " (1): ELU(alpha=1.0)\n", + " (2): Linear(in_features=64, out_features=64, bias=True)\n", + " (3): ELU(alpha=1.0)\n", + " (4): Linear(in_features=64, out_features=64, bias=True)\n", + " (5): ELU(alpha=1.0)\n", + " (6): Linear(in_features=64, out_features=64, bias=True)\n", + " (7): ELU(alpha=1.0)\n", + " (8): Linear(in_features=64, out_features=64, bias=True)\n", + " (9): ELU(alpha=1.0)\n", + " (10): Linear(in_features=64, out_features=3, bias=True)\n", + " )\n", + ")" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "estimator = NSE(3, 2, hidden_features=[64] * 5, activation=nn.ELU)\n", + "estimator" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then, we train our regressor using a standard neural network training routine." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████████████████████████████| 128/128 [01:07<00:00, 1.91epoch/s, loss=0.153]\n" + ] + } + ], + "source": [ + "loss = NSELoss(estimator)\n", + "optimizer = optim.AdamW(estimator.parameters(), lr=1e-3)\n", + "scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, 128)\n", + "step = GDStep(optimizer, clip=1.0) # gradient descent step with gradient clipping\n", + "\n", + "estimator.train()\n", + "\n", + "with tqdm(range(128), unit='epoch', ncols=88) as tq:\n", + " for epoch in tq:\n", + " losses = torch.stack([\n", + " step(loss(theta, x))\n", + " for theta, x in islice(loader, 256) # 256 batches per epoch\n", + " ])\n", + "\n", + " tq.set_postfix(loss=losses.mean().item())\n", + "\n", + " scheduler.step()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Inference\n", + "\n", + "Now that we have an estimator of the score, we can solve the probability flow ODE to sample from the posterior $p_\\phi(\\theta | x)$. For convenience, the `flow` method of the `NSE` class returns a conditional distribution which can be sampled from." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "theta_star = prior.sample()\n", + "x_star = simulator(theta_star)\n", + "\n", + "estimator.eval()\n", + "\n", + "with torch.no_grad():\n", + " samples = estimator.flow(x_star).sample((2**16,))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.rcParams.update(nice_rc(latex=True)) # nicer plot settings\n", + "\n", + "fig = corner(\n", + " samples,\n", + " smooth=2,\n", + " domain=(LOWER, UPPER),\n", + " labels=LABELS,\n", + " legend=r'$p_\\phi(\\theta | x^*)$',\n", + " figsize=(4.8, 4.8),\n", + ")\n", + "\n", + "mark_point(fig, theta_star)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `log_prob` method of the distribution returned by `flow` is a stochastic estimator of the true log-density. Therefore, one should average over a sufficient number of evaluations to attain small errors." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.6841 ± 0.1945\n" + ] + } + ], + "source": [ + "with torch.no_grad():\n", + " log_p = estimator.flow(x_star).log_prob(theta_star.expand(1024, -1))\n", + "\n", + "mu = log_p.mean().item()\n", + "sigma = log_p.std() / 1024 ** 0.5\n", + "\n", + "print(f'{mu:.4f} ± {sigma:.4f}')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:lampe]", + "language": "python", + "name": "conda-env-lampe-py" + }, + "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.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorials/04_coverage.ipynb b/tutorials/05_coverage.ipynb similarity index 100% rename from tutorials/04_coverage.ipynb rename to tutorials/05_coverage.ipynb diff --git a/tutorials/05_embedding.ipynb b/tutorials/06_embedding.ipynb similarity index 100% rename from tutorials/05_embedding.ipynb rename to tutorials/06_embedding.ipynb