From 49abb7b1faaf101c66351fadad21ef01edc5abfb Mon Sep 17 00:00:00 2001 From: daeargryn Date: Tue, 7 Jan 2025 15:37:37 +0000 Subject: [PATCH] mixing circuits and normalizing flows notebook --- ...ixing-circuits-and-normalizing-flows.ipynb | 1114 +++++++++++++++++ 1 file changed, 1114 insertions(+) create mode 100644 notebooks/mixing-circuits-and-normalizing-flows.ipynb diff --git a/notebooks/mixing-circuits-and-normalizing-flows.ipynb b/notebooks/mixing-circuits-and-normalizing-flows.ipynb new file mode 100644 index 00000000..b7d93811 --- /dev/null +++ b/notebooks/mixing-circuits-and-normalizing-flows.ipynb @@ -0,0 +1,1114 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Mixing Probabilistic Circuits with Normalizing Flows" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this notebook, we provide an example of mixing probabilistic circuits (PCs) — implemented using `cirkit` — with normalizing flows (NFs). Probabilistic circuits are able to model complex join densities, while preserving tractability as long as certain structural properties are satisfied. `cirkit` provides the ingredients for compiling such circuits (details in `region-graphs-and-parametrisation.ipynb`). Expressiveness and tractability make circuits good candidates as normalizing flows *base distributions*.\n", + "\n", + "In this example, we try to estimate two *toy* densities in 2 dimensions. First, we adopt the library `zuko`, which implements a wide range of state of the art normalizing flows using `pytorch`. We provide an example of how to wrap a circuit from `cirkit` into a distribution compatible with `zuko`. Then, we compare and discuss a number of training configurations, involving both probabilistic circuits and normalizing flows." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import numpy as np\n", + "import pandas as pd\n", + "import random\n", + "import matplotlib.pyplot as plt\n", + "import copy\n", + "\n", + "SEED = 47\n", + "random.seed(SEED)\n", + "torch.manual_seed(SEED)\n", + "np.random.seed(SEED)\n", + "\n", + "device = 'cuda'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## `zuko` wrapper for `cirkit`" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`Zuko`'s backend relies on pytorch distribution objects (`torch.distribution.Distributions`) for base distributions. For our purposes, we can wrap our circuit in a `Distribution` object, defining the `log_prob`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from torch import Tensor, Size\n", + "from torch.distributions import Distribution\n", + "\n", + "class TorchCircuitDistribution(Distribution):\n", + " # ------------ Distribution object attributes interpretation --------------- #\n", + " # batch_shape: describes the shape of not identically distributed draws. Since our circuit has only one parametrization `batch_shape=Size([1])`\n", + " # event_shape: describe the shape of a single draw (can be dependent). In our case, since it is a scalar value, `event_shape=Size([])` \n", + " def __init__(self, circuit, batch_shape=Size([1]), event_shape=Size([])):\n", + " super().__init__(batch_shape=batch_shape, event_shape=event_shape )\n", + " \n", + " self.circuit = circuit\n", + "\n", + " def log_prob(self, x: Tensor):\n", + " return self.circuit(x) # return the circuit log-likelihood" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then, `zuko` base distributions are implemented as `zuko.flows.LazyDistribution` objects. They extend `torch.nn.module`, hence allow for the registration of other modules. The `forward` method returns a pytorch distribution object which, in this case, is our custom `TorchCircuitDistribution`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from zuko.flows import LazyDistribution\n", + "from cirkit.backend.torch.circuits import TorchCircuit\n", + "\n", + "class TorchCircuitBaseDistribution(LazyDistribution):\n", + " def __init__(self, circuit: TorchCircuit, trainable=False):\n", + " super().__init__()\n", + "\n", + " if trainable:\n", + " self.add_module('_circuit', circuit) # we register the module if we want it to be trained with the flow\n", + " self.circuit = TorchCircuitDistribution(circuit)\n", + "\n", + " def forward(self, c: Tensor = None):\n", + " return self.circuit # return the whole circuit" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Experiments" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this section, we estimate two slightly different densities. We can observe that for a flow with a shallow transformation and a normal base distribution, such densities are difficult to be estimated. Replacing the standard base distribution with a pre-trained flow improves the quality of the estimation. In addition, allowing for the circuit to be fine-tuned along with the flow weights leads also to an improvement." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Training and evaluation loops" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We use the same training and evaluation loops for both circuits and flows. Depending on the model, the loop function receives a different forward function" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# ---------- Flow forward function ---------- #\n", + "def flow_forward(flow, x):\n", + " x = x.unsqueeze(dim=1)\n", + " return flow().log_prob(x)\n", + "\n", + "# ---------- Circuit forward function ---------- #\n", + "def circuit_forward(circuit, x):\n", + " x = x.unsqueeze(dim=1)\n", + " return circuit(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "def training_loop(f, model: torch.nn.Module, train_loader, val_loader, lr, patience=3, tol=1e-6, maximize=False, epochs=100, device='cuda'):\\\n", + " # optimizer initialization\n", + " optimizer = torch.optim.Adam(model.parameters(), lr=lr, maximize=maximize)\n", + " losses = []\n", + " \n", + " # --------- Training loop --------- #\n", + " curr, min_loss = 0, float('inf')\n", + " for i in range(1, epochs+1):\n", + " running_loss=0.0\n", + " running_val_loss=0.0\n", + " for input_tensor in train_loader:\n", + " input_tensor = input_tensor.to(device)\n", + " loss = -f(model, input_tensor).mean()\n", + " loss.backward()\n", + " running_loss += loss\n", + "\n", + " optimizer.step()\n", + " optimizer.zero_grad()\n", + " epoch_loss = (running_loss / len(train_loader)).cpu().detach().numpy()\n", + " losses.append(epoch_loss)\n", + "\n", + " # --------- Validation loop --------- #\n", + " for input_tensor in val_loader:\n", + " input_tensor = input_tensor.to(device)\n", + " loss = -f(model, input_tensor).mean()\n", + " running_val_loss += loss\n", + " val_loss = (running_val_loss / len(val_loader)).cpu().detach().numpy()\n", + " if val_loss >= min_loss + tol:\n", + " curr += 1\n", + " if curr > patience:\n", + " break\n", + " else:\n", + " curr = 0\n", + " min_loss = val_loss\n", + " if i % 5 == 0:\n", + " print(f'Step: {i} Average val NLL: {val_loss}')\n", + " \n", + " return losses\n", + "\n", + "def evaluate_model(f, model, test_dataloader, device='cuda') -> list:\n", + " test_running_loss = 0.0\n", + " with torch.no_grad():\n", + " for input_tensor in test_dataloader:\n", + " input_tensor = input_tensor.to(device)\n", + " loss = -f(model, input_tensor).mean()\n", + " test_running_loss += loss\n", + "\n", + " hold_out = (test_running_loss/len(test_dataloader)).item()\n", + " return hold_out" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A utility function to plot a mesh grid of a model estimated density" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "def print_density(model, f, ax=None, x1_bounds=(-1.5,2.5), x2_bounds=(-1,1.5), device='cuda'):\n", + " model.eval()\n", + " with torch.no_grad():\n", + " num_samples = 400\n", + " x2 = np.linspace(0, 1, num_samples)*(x2_bounds[1] - x2_bounds[0]) + x2_bounds[0]\n", + " x1 = np.linspace(0, 1, num_samples)*(x1_bounds[1] - x1_bounds[0]) + x1_bounds[0]\n", + " x1v, x2v = np.meshgrid(x1, x2)\n", + " X_meshgrid_np = np.stack((x1v,x2v), axis=-1).reshape(-1,2)\n", + " X_meshgrid = torch.from_numpy(X_meshgrid_np).float()\n", + " X_meshgrid = X_meshgrid.to(device)\n", + " log_probs = f(model, X_meshgrid).float()\n", + " log_probs = log_probs.reshape(num_samples, num_samples)\n", + " probs = torch.exp(log_probs)\n", + " instance = ax\n", + " if instance is None:\n", + " instance = plt\n", + " ax = instance.imshow(probs.cpu().detach().numpy(), extent=(*x1_bounds, *x2_bounds), origin=\"lower\")\n", + " return log_probs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Instantiating a Normalizing Flow using `zuko`" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We adopt a lightweight coupling flow, *i.e.,* [NICE (Dinh et al. 2014)](https://arxiv.org/abs/1410.8516). The default base distribution is a multivariate normal distribution with diagonal covariance matrix. The same untrained flow is reused across the experiment configurations." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "UnconditionalDistribution(DiagNormal(loc: torch.Size([2]), scale: torch.Size([2])))" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from zuko.flows import NICE\n", + "basic_flow = NICE( \n", + " features = 2, # 2D distribution\n", + " transforms = 5, # number of transformations\n", + " hidden_features = (16, 16), # features of the hidden layer of the transformation\n", + " randmask = True, # use a random coupling mask\n", + ").to(device=device) \n", + "basic_flow.base # flow base distribution" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Instantiating a Probabilistic Circuit using `cirkit`" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For details about the implementation, refer to `region-graphs-and-parametrisation.ipynb`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from cirkit.templates import region_graph as rg\n", + "from cirkit.pipeline import compile\n", + "from cirkit.symbolic.layers import GaussianLayer\n", + "from cirkit.templates.utils import (\n", + " Parameterization,\n", + " parameterization_to_factory\n", + ")\n", + "\n", + "# ----------- Region graph ----------- #\n", + "region_graph = rg.algorithms.FullyFactorized(num_variables=2)\n", + "\n", + "# ----------- Building the symbolic circuit from the RG ----------- #\n", + "sum_weight_param = Parameterization(activation='softmax', initialization='normal')\n", + "\n", + "symbolic_circuit = region_graph.build_circuit(\n", + " input_factory=GaussianLayer,\n", + " sum_product='tucker',\n", + " sum_weight_factory=parameterization_to_factory(sum_weight_param),\n", + " num_input_units=8,\n", + " num_sum_units=8,\n", + ")\n", + "# ----------- Compiling the circuit ----------- #\n", + "basic_circuit = compile(symbolic_circuit).to(device)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Ring-shaped distribution" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Dataset preparation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We load an artificial dataset containing points drawn from a *ring-shaped* distribution." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "from datasets import load_artificial_dataset\n", + "from torch.utils.data import DataLoader\n", + "\n", + "batch_size = 128\n", + "data = load_artificial_dataset(name='ring', num_samples=5_000, seed=SEED, sigma=0.05)\n", + "\n", + "train_loader = DataLoader( data['train'], batch_size=batch_size, shuffle=True)\n", + "valid_loader = DataLoader( data['valid'], batch_size=batch_size, shuffle=False)\n", + "test_loader = DataLoader( data['test'] , batch_size=batch_size, shuffle=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bounds = (-2, 2)\n", + "ground_truth = np.concatenate(list(data.values()))\n", + "plt.hist2d(*ground_truth.T, bins=256, range=(bounds, bounds), density=True, linewidths=0, rasterized=True)\n", + "plt.gca().set_aspect('equal', adjustable='box')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Basic NF" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We train the basic Normalizing Flow previously initialized." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Step: 5 Average val NLL: 2.1033763885498047\n", + "Step: 10 Average val NLL: 1.651458978652954\n", + "Step: 15 Average val NLL: 1.5758607387542725\n", + "Step: 20 Average val NLL: 1.499655842781067\n" + ] + } + ], + "source": [ + "trained_flow = copy.deepcopy(basic_flow) # copy the prototype\n", + "\n", + "_ = training_loop(\n", + " model = trained_flow,\n", + " f = flow_forward,\n", + " train_loader = train_loader,\n", + " val_loader = valid_loader,\n", + " epochs = 500,\n", + " lr = 0.005,\n", + " device = device,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As for the NF, we train the basic PC previously initialized." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Step: 5 Average val NLL: 1.3469688892364502\n", + "Step: 10 Average val NLL: 1.3701229095458984\n", + "Step: 15 Average val NLL: 1.3435323238372803\n" + ] + } + ], + "source": [ + "trained_circuit = copy.deepcopy(basic_circuit) # copy the prototype\n", + "\n", + "_ = training_loop(\n", + " model = trained_circuit,\n", + " f = circuit_forward,\n", + " train_loader= train_loader,\n", + " val_loader = valid_loader,\n", + " epochs = 500,\n", + " lr = 0.05,\n", + " device = device,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### NF+Frozen PC" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we define a new flow with the very same transformation of the `basic_flow` but replacing the base distribution with our pre-trained circuit. Here, we *freeze* the weights of the circuit, not including them in the training parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Step: 5 Average val NLL: 1.1999735832214355\n", + "Step: 10 Average val NLL: 1.1519731283187866\n", + "Step: 15 Average val NLL: 1.165776252746582\n", + "Step: 20 Average val NLL: 1.1396021842956543\n" + ] + } + ], + "source": [ + "from zuko.flows import Flow\n", + "\n", + "frozen_circuit = copy.deepcopy(trained_circuit) # copy the prototype\n", + "transform = copy.deepcopy(basic_flow.transform) # copy the prototype transform\n", + "\n", + "# wrap our circuit, not allowing for training\n", + "basic_distribution_circuit = TorchCircuitBaseDistribution(frozen_circuit, trainable=False)\n", + "\n", + "# initialize a new flow with the original transform and our custom circuit base distribution\n", + "custom_flow = Flow(transform=transform, base=basic_distribution_circuit) \n", + "\n", + "# train the custom flow\n", + "_ = training_loop(\n", + " model = custom_flow,\n", + " f = flow_forward,\n", + " train_loader = train_loader,\n", + " val_loader = valid_loader,\n", + " epochs = 500,\n", + " lr = 0.005,\n", + " device = device,\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### NF+PC" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Again, we define a new flow with the very same transformation of the `basic_flow`. We replace the base distribution with our pre-trained circuit but allowing for fine-tuning its parameters along with the transformation." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Step: 5 Average val NLL: 1.0473884344100952\n" + ] + } + ], + "source": [ + "circuit = copy.deepcopy(trained_circuit) # copy the prototype\n", + "transform = copy.deepcopy(basic_flow.transform) # copy the prototype transform\n", + "\n", + "# wrap our circuit, allowing for training\n", + "basic_distribution_circuit_2 = TorchCircuitBaseDistribution(circuit, trainable=True)\n", + "\n", + "# initialize a new flow with the original transform and our custom circuit base distribution\n", + "\n", + "# train the custom flow\n", + "custom_flow_2 = Flow(transform=transform, base=basic_distribution_circuit_2)\n", + "_ = training_loop(\n", + " model = custom_flow_2,\n", + " f = flow_forward,\n", + " train_loader = train_loader,\n", + " val_loader = valid_loader,\n", + " epochs = 500,\n", + " lr = 0.005,\n", + " device = device,\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We evaluate our models on the test set" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[None,\n", + " 1.471468448638916,\n", + " 1.2785756587982178,\n", + " 1.1624338626861572,\n", + " 0.9933033585548401]" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "hold_out = [None] * 5\n", + "\n", + "hold_out[1] = evaluate_model(\n", + " model=trained_flow,\n", + " f=flow_forward,\n", + " test_dataloader=test_loader,\n", + " device=device,\n", + ")\n", + "\n", + "hold_out[2] = evaluate_model(\n", + " model=trained_circuit,\n", + " f=circuit_forward,\n", + " test_dataloader=test_loader,\n", + " device=device,\n", + ")\n", + "\n", + "hold_out[3] = evaluate_model(\n", + " model=custom_flow,\n", + " f=flow_forward,\n", + " test_dataloader=test_loader,\n", + " device=device,\n", + ")\n", + "\n", + "hold_out[4] = evaluate_model(\n", + " model=custom_flow_2,\n", + " f=flow_forward,\n", + " test_dataloader=test_loader,\n", + " device=device,\n", + ")\n", + "hold_out" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And plot the results." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# ------------- Plotting ground truth and estimated densities ----------------- #\n", + "fig, axes = plt.subplots(1, 5, sharex=True, sharey=True, figsize=(10,3))\n", + "\n", + "# ------------- Ground truth ----------------- #\n", + "hist=axes[0].hist2d(*ground_truth.T, bins=256, range=(bounds, bounds), density=True, linewidths=0, rasterized=True)\n", + "axes[0].set_aspect('equal', adjustable='box')\n", + "axes[0].set_title('Ground Truth')\n", + "axes[0].set_xlabel('Test NLL:')\n", + "\n", + "# ------------- Basic NF ----------------- #\n", + "print_density(trained_flow, flow_forward, ax=axes[1], x1_bounds=bounds, x2_bounds=bounds, device=device)\n", + "axes[1].set_title('Basic NF')\n", + "axes[1].set_xlabel(f'{hold_out[1]:.3f}')\n", + "\n", + "# ------------- Basic PC ----------------- #\n", + "print_density(trained_circuit, circuit_forward, ax=axes[2], x1_bounds=bounds, x2_bounds=bounds, device=device)\n", + "axes[2].set_title('Basic PC')\n", + "axes[2].set_xlabel(f'{hold_out[2]:.3f}')\n", + "\n", + "# ------------- NF+frozen PC ----------------- #\n", + "print_density(custom_flow, flow_forward, ax=axes[3], x1_bounds=bounds, x2_bounds=bounds, device=device)\n", + "axes[3].set_title('NF+frozen PC')\n", + "axes[3].set_xlabel(f'{hold_out[3]:.3f}')\n", + "\n", + "# ------------- NF+PC ----------------- #\n", + "print_density(custom_flow_2, flow_forward, ax=axes[4], x1_bounds=bounds, x2_bounds=bounds, device=device)\n", + "axes[4].set_title('NF+PC')\n", + "_=axes[4].set_xlabel(f'{hold_out[4]:.3f}')\n", + "\n", + "# ------------- Making the colormap uniform across the plots ----------------- #\n", + "vmin = float('inf')\n", + "vmax = float('-inf')\n", + "# axes[0].axis('off')\n", + "hmin, hmax = hist[3].get_clim()\n", + "vmin = min(vmin, hmin/len(train_loader.dataset))\n", + "vmax = max(vmax, hmax/len(train_loader.dataset))\n", + "for ax in axes[1:]:\n", + " # ax.axis('off')\n", + " vmin = min(vmin, ax.get_images()[0].get_array().min())\n", + " vmax = max(vmax, ax.get_images()[0].get_array().max())\n", + "for ax in axes[1:]:\n", + " ax.get_images()[0].set_clim(vmin=vmin, vmax=vmax)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Spiral-shape distribution" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Dataset preparation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We load an artificial dataset containing points drawn from a *spiral-shaped* distribution." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "batch_size = 128\n", + "data = load_artificial_dataset(name='spiral', num_samples=5_000, seed=SEED, sigma=0.2)\n", + "\n", + "train_loader = DataLoader( data['train'], batch_size=batch_size, shuffle=True)\n", + "valid_loader = DataLoader( data['valid'], batch_size=batch_size, shuffle=False)\n", + "test_loader = DataLoader( data['test'] , batch_size=batch_size, shuffle=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bounds = (-2, 2)\n", + "ground_truth = np.concatenate(list(data.values()))\n", + "plt.hist2d(*ground_truth.T, bins=256, range=(bounds, bounds), density=True, linewidths=0, rasterized=True)\n", + "plt.gca().set_aspect('equal', adjustable='box')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Basic NF" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We train the basic Normalizing Flow previously initialized." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Step: 5 Average val NLL: 2.6811788082122803\n", + "Step: 10 Average val NLL: 2.572209358215332\n", + "Step: 15 Average val NLL: 2.4464340209960938\n", + "Step: 20 Average val NLL: 2.3608341217041016\n", + "Step: 25 Average val NLL: 2.3022403717041016\n", + "Step: 30 Average val NLL: 2.2659425735473633\n", + "Step: 35 Average val NLL: 2.215879440307617\n", + "Step: 40 Average val NLL: 2.22873592376709\n" + ] + } + ], + "source": [ + "trained_flow = copy.deepcopy(basic_flow) # copy the prototype\n", + "\n", + "_ = training_loop(\n", + " model = trained_flow,\n", + " f = flow_forward,\n", + " train_loader = train_loader,\n", + " val_loader = valid_loader,\n", + " epochs = 500,\n", + " lr = 0.005,\n", + " device = device,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As for the NF, we train the basic PC previously initialized." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Step: 5 Average val NLL: 2.1133973598480225\n", + "Step: 10 Average val NLL: 2.0757226943969727\n" + ] + } + ], + "source": [ + "trained_circuit = copy.deepcopy(basic_circuit) # copy the prototype\n", + "\n", + "_ = training_loop(\n", + " model = trained_circuit,\n", + " f = circuit_forward,\n", + " train_loader= train_loader,\n", + " val_loader = valid_loader,\n", + " epochs = 500,\n", + " lr = 0.05,\n", + " device = device,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### NF+Frozen PC" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we define a new flow with the very same transformation of the `basic_flow` but replacing the base distribution with our pre-trained circuit. Here, we *freeze* the weights of the circuit, not including them in the training parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Step: 5 Average val NLL: 1.9790362119674683\n", + "Step: 10 Average val NLL: 1.9341130256652832\n", + "Step: 15 Average val NLL: 1.95265531539917\n" + ] + } + ], + "source": [ + "frozen_circuit = copy.deepcopy(trained_circuit) # copy the prototype\n", + "transform = copy.deepcopy(basic_flow.transform) # copy the prototype transform\n", + "\n", + "# wrap our circuit, not allowing for training\n", + "basic_distribution_circuit = TorchCircuitBaseDistribution(frozen_circuit, trainable=False)\n", + "\n", + "# initialize a new flow with the original transform and our custom circuit base distribution\n", + "custom_flow = Flow(transform=transform, base=basic_distribution_circuit) \n", + "\n", + "# train the custom flow\n", + "_ = training_loop(\n", + " model = custom_flow,\n", + " f = flow_forward,\n", + " train_loader = train_loader,\n", + " val_loader = valid_loader,\n", + " epochs = 500,\n", + " lr = 0.005,\n", + " device = device,\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### NF+PC" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Again, we define a new flow with the very same transformation of the `basic_flow`. We replace the base distribution with our pre-trained circuit but allowing for fine-tuning its parameters along with the transformation." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Step: 5 Average val NLL: 1.88126540184021\n", + "Step: 10 Average val NLL: 1.8582775592803955\n", + "Step: 15 Average val NLL: 1.8509305715560913\n" + ] + } + ], + "source": [ + "circuit = copy.deepcopy(trained_circuit) # copy the prototype\n", + "transform = copy.deepcopy(basic_flow.transform) # copy the prototype transform\n", + "\n", + "# wrap our circuit, allowing for training\n", + "basic_distribution_circuit_2 = TorchCircuitBaseDistribution(circuit, trainable=True)\n", + "\n", + "# initialize a new flow with the original transform and our custom circuit base distribution\n", + "\n", + "# train the custom flow\n", + "custom_flow_2 = Flow(transform=transform, base=basic_distribution_circuit_2)\n", + "_ = training_loop(\n", + " model = custom_flow_2,\n", + " f = flow_forward,\n", + " train_loader = train_loader,\n", + " val_loader = valid_loader,\n", + " epochs = 500,\n", + " lr = 0.005,\n", + " device = device,\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We evaluate our models on the test set" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[None,\n", + " 2.2396676540374756,\n", + " 2.0494580268859863,\n", + " 1.8788666725158691,\n", + " 1.810505986213684]" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "hold_out = [None] * 5\n", + "\n", + "hold_out[1] = evaluate_model(\n", + " model=trained_flow,\n", + " f=flow_forward,\n", + " test_dataloader=test_loader,\n", + " device=device,\n", + ")\n", + "\n", + "hold_out[2] = evaluate_model(\n", + " model=trained_circuit,\n", + " f=circuit_forward,\n", + " test_dataloader=test_loader,\n", + " device=device,\n", + ")\n", + "\n", + "hold_out[3] = evaluate_model(\n", + " model=custom_flow,\n", + " f=flow_forward,\n", + " test_dataloader=test_loader,\n", + " device=device,\n", + ")\n", + "\n", + "hold_out[4] = evaluate_model(\n", + " model=custom_flow_2,\n", + " f=flow_forward,\n", + " test_dataloader=test_loader,\n", + " device=device,\n", + ")\n", + "hold_out" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And plot the results." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# ------------- Plotting ground truth and estimated densities ----------------- #\n", + "fig, axes = plt.subplots(1, 5, sharex=True, sharey=True, figsize=(10,3))\n", + "\n", + "# ------------- Ground truth ----------------- #\n", + "hist=axes[0].hist2d(*ground_truth.T, bins=256, range=(bounds, bounds), density=True, linewidths=0, rasterized=True)\n", + "axes[0].set_aspect('equal', adjustable='box')\n", + "axes[0].set_title('Ground Truth')\n", + "axes[0].set_xlabel('Test NLL:')\n", + "\n", + "# ------------- Basic NF ----------------- #\n", + "print_density(trained_flow, flow_forward, ax=axes[1], x1_bounds=bounds, x2_bounds=bounds, device=device)\n", + "axes[1].set_title('Basic NF')\n", + "axes[1].set_xlabel(f'{hold_out[1]:.3f}')\n", + "\n", + "# ------------- Basic PC ----------------- #\n", + "print_density(trained_circuit, circuit_forward, ax=axes[2], x1_bounds=bounds, x2_bounds=bounds, device=device)\n", + "axes[2].set_title('Basic PC')\n", + "axes[2].set_xlabel(f'{hold_out[2]:.3f}')\n", + "\n", + "# ------------- NF+frozen PC ----------------- #\n", + "print_density(custom_flow, flow_forward, ax=axes[3], x1_bounds=bounds, x2_bounds=bounds, device=device)\n", + "axes[3].set_title('NF+frozen PC')\n", + "axes[3].set_xlabel(f'{hold_out[3]:.3f}')\n", + "\n", + "# ------------- NF+PC ----------------- #\n", + "print_density(custom_flow_2, flow_forward, ax=axes[4], x1_bounds=bounds, x2_bounds=bounds, device=device)\n", + "axes[4].set_title('NF+PC')\n", + "_=axes[4].set_xlabel(f'{hold_out[4]:.3f}')\n", + "\n", + "# ------------- Making the colormap uniform across the plots ----------------- #\n", + "vmin = float('inf')\n", + "vmax = float('-inf')\n", + "# axes[0].axis('off')\n", + "hmin, hmax = hist[3].get_clim()\n", + "vmin = min(vmin, hmin/len(train_loader.dataset))\n", + "vmax = max(vmax, hmax/len(train_loader.dataset))\n", + "for ax in axes[1:]:\n", + " # ax.axis('off')\n", + " vmin = min(vmin, ax.get_images()[0].get_array().min())\n", + " vmax = max(vmax, ax.get_images()[0].get_array().max())\n", + "for ax in axes[1:]:\n", + " ax.get_images()[0].set_clim(vmin=vmin, vmax=vmax)\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}