diff --git a/.readthedocs.yaml b/.readthedocs.yaml index 3670ca6..ed643bf 100644 --- a/.readthedocs.yaml +++ b/.readthedocs.yaml @@ -6,7 +6,7 @@ build: python: "3.11" sphinx: - configuration: docs/conf.py + configuration: docs/source/conf.py python: install: diff --git a/README.md b/README.md index 3fe5c48..4c86fe0 100644 --- a/README.md +++ b/README.md @@ -30,16 +30,20 @@ print(log_prob.shape) # (100,) print(x_new.shape) # (50, 3) ``` -We provide more examples [here](examples/). +Check examples and documentation, including the list of supported architectures [here](https://torchflows.readthedocs.io/en/latest/). +We also provide examples [here](examples/). ## Installing -Install via pip: +We support Python versions 3.7 and upwards. + +Install Torchflows via pip: + ``` pip install torchflows ``` -Install the package directly from Github: +Install Torchflows directly from Github: ``` pip install git+https://github.com/davidnabergoj/torchflows.git @@ -53,59 +57,3 @@ cd torchflows pip install -r requirements.txt ``` -We support Python versions 3.7 and upwards. - -## Brief background - -A normalizing flow (NF) is a flexible trainable distribution. -It is defined as a bijective transformation of a simple distribution, such as a standard Gaussian. -The bijection is typically an invertible neural network. -Training a NF using a dataset means optimizing the bijection's parameters to make the dataset likely under the NF. -We can use a NF to compute the probability of a data point or to independently sample data from the process that -generated our dataset. - -The density of a NF $q(x)$ with the bijection $f(z) = x$ and base distribution $p(z)$ is defined as: -$$\log q(x) = \log p(f^{-1}(x)) + \log\left|\det J_{f^{-1}}(x)\right|.$$ -Sampling from a NF means sampling from the simple distribution and transforming the sample using the bijection. - -## Supported architectures - -We list supported NF architectures below. -We classify architectures as either autoregressive, residual, or continuous; as defined -by [Papamakarios et al. (2021)](https://arxiv.org/abs/1912.02762). -We specify whether the forward and inverse passes are exact; otherwise they are numerical or not implemented (Planar, -Radial, and Sylvester flows). -An exact forward pass guarantees exact density estimation, whereas an exact inverse pass guarantees exact sampling. -Note that the directions can always be reversed, which enables exact computation for the opposite task. -We also specify whether the logarithm of the Jacobian determinant of the transformation is exact or computed numerically. - -| Architecture | Bijection type | Exact forward | Exact inverse | Exact log determinant | -|--------------------------------------------------------------------------|:--------------------------:|:---------------:|:-------------:|:---------------------:| -| [NICE](http://arxiv.org/abs/1410.8516) | Autoregressive | ✔ | ✔ | ✔ | -| [Real NVP](http://arxiv.org/abs/1605.08803) | Autoregressive | ✔ | ✔ | ✔ | -| [MAF](http://arxiv.org/abs/1705.07057) | Autoregressive | ✔ | ✔ | ✔ | -| [IAF](http://arxiv.org/abs/1606.04934) | Autoregressive | ✔ | ✔ | ✔ | -| [Rational quadratic NSF](http://arxiv.org/abs/1906.04032) | Autoregressive | ✔ | ✔ | ✔ | -| [Linear rational NSF](http://arxiv.org/abs/2001.05168) | Autoregressive | ✔ | ✔ | ✔ | -| [NAF](http://arxiv.org/abs/1804.00779) | Autoregressive | ✔ | ✗ | ✔ | -| [UMNN](http://arxiv.org/abs/1908.05164) | Autoregressive | ✗ | ✗ | ✔ | -| [Planar](https://onlinelibrary.wiley.com/doi/abs/10.1002/cpa.21423) | Residual | ✔ | ✗ | ✔ | -| [Radial](https://proceedings.mlr.press/v37/rezende15.html) | Residual | ✔ | ✗ | ✔ | -| [Sylvester](http://arxiv.org/abs/1803.05649) | Residual | ✔ | ✗ | ✔ | -| [Invertible ResNet](http://arxiv.org/abs/1811.00995) | Residual | ✔ | ✗ | ✗ | -| [ResFlow](http://arxiv.org/abs/1906.02735) | Residual | ✔ | ✗ | ✗ | -| [Proximal ResFlow](http://arxiv.org/abs/2211.17158) | Residual | ✔ | ✗ | ✗ | -| [FFJORD](http://arxiv.org/abs/1810.01367) | Continuous | ✗ | ✗ | ✗ | -| [RNODE](http://arxiv.org/abs/2002.02798) | Continuous | ✗ | ✗ | ✗ | -| [DDNF](http://arxiv.org/abs/1810.03256) | Continuous | ✗ | ✗ | ✗ | -| [OT flow](http://arxiv.org/abs/2006.00104) | Continuous | ✗ | ✗ | ✗ | - - -We also support simple bijections (all with exact forward passes, inverse passes, and log determinants): - -* Permutation -* Elementwise translation (shift vector) -* Elementwise scaling (diagonal matrix) -* Rotation (orthogonal matrix) -* Triangular matrix -* Dense matrix (using the QR or LU decomposition) diff --git a/docs/Makefile b/docs/Makefile index 269cadc..d0c3cbf 100644 --- a/docs/Makefile +++ b/docs/Makefile @@ -17,4 +17,4 @@ help: # Catch-all target: route all unknown targets to Sphinx using the new # "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). %: Makefile - @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) \ No newline at end of file + @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) diff --git a/docs/make.bat b/docs/make.bat index 5394189..dc1312a 100644 --- a/docs/make.bat +++ b/docs/make.bat @@ -10,8 +10,6 @@ if "%SPHINXBUILD%" == "" ( set SOURCEDIR=source set BUILDDIR=build -if "%1" == "" goto help - %SPHINXBUILD% >NUL 2>NUL if errorlevel 9009 ( echo. @@ -21,10 +19,12 @@ if errorlevel 9009 ( echo.may add the Sphinx directory to PATH. echo. echo.If you don't have Sphinx installed, grab it from - echo.http://sphinx-doc.org/ + echo.https://www.sphinx-doc.org/ exit /b 1 ) +if "%1" == "" goto help + %SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% goto end @@ -32,4 +32,4 @@ goto end %SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% :end -popd \ No newline at end of file +popd diff --git a/docs/notebooks/computing_log_determinants.ipynb b/docs/notebooks/computing_log_determinants.ipynb new file mode 100644 index 0000000..117ff46 --- /dev/null +++ b/docs/notebooks/computing_log_determinants.ipynb @@ -0,0 +1,90 @@ +{ + "cells": [ + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "# Computing the log determinant of the Jacobian\n", + "\n", + "We show how to compute and retrieve the log determinant of the Jacobian of a bijective transformation. We use Real NVP as an example." + ], + "id": "624f99599895f0fd" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-08-13T16:39:40.646799Z", + "start_time": "2024-08-13T16:39:38.868039Z" + } + }, + "cell_type": "code", + "source": [ + "import torch\n", + "from torchflows import Flow\n", + "from torchflows.architectures import RealNVP\n", + "\n", + "torch.manual_seed(0)\n", + "\n", + "batch_shape = (5, 7)\n", + "event_shape = (2, 3)\n", + "x = torch.randn(size=(*batch_shape, *event_shape))\n", + "z = torch.randn(size=(*batch_shape, *event_shape))\n", + "\n", + "bijection = RealNVP(event_shape=event_shape)\n", + "flow = Flow(bijection)\n", + "\n", + "_, log_det_forward = flow.bijection.forward(x)\n", + "_, log_det_inverse = flow.bijection.inverse(z)" + ], + "id": "3f74b61a9929dd3b", + "outputs": [], + "execution_count": 1 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-08-13T16:39:40.662420Z", + "start_time": "2024-08-13T16:39:40.653696Z" + } + }, + "cell_type": "code", + "source": [ + "print(f'{log_det_forward.shape = }')\n", + "print(f'{log_det_inverse.shape = }')" + ], + "id": "3c49e132d9c041c2", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "log_det_forward.shape = torch.Size([5, 7])\n", + "log_det_inverse.shape = torch.Size([5, 7])\n" + ] + } + ], + "execution_count": 2 + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/notebooks/image_modeling.ipynb b/docs/notebooks/image_modeling.ipynb new file mode 100644 index 0000000..cc1db94 --- /dev/null +++ b/docs/notebooks/image_modeling.ipynb @@ -0,0 +1,133 @@ +{ + "cells": [ + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "# Image modeling with normalizing flows\n", + "\n", + "When working with images, we can use specialized multiscale flow architectures. We can also use standard normalizing flows, which internally work with a flattened image. Note that multiscale architectures expect input images with shape `(channels, height, width)`." + ], + "id": "df68afe10da259a1" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-08-13T17:20:05.803231Z", + "start_time": "2024-08-13T17:20:03.001656Z" + } + }, + "cell_type": "code", + "source": [ + "from torchvision.datasets import MNIST\n", + "import torch\n", + "\n", + "torch.manual_seed(0)\n", + "\n", + "# pip install torchvision\n", + "dataset = MNIST(root='./data', download=True, train=True)\n", + "train_data = dataset.data.float()[:, None]\n", + "train_data = train_data[torch.randperm(len(train_data))]\n", + "train_data = (train_data - torch.mean(train_data)) / torch.std(train_data)\n", + "x_train, x_val = train_data[:1000], train_data[1000:1200]\n", + "\n", + "print(f'{x_train.shape = }')\n", + "print(f'{x_val.shape = }')\n", + "\n", + "image_shape = train_data.shape[1:]\n", + "print(f'{image_shape = }')" + ], + "id": "b4d5e1888ff6a0e7", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x_train.shape = torch.Size([1000, 1, 28, 28])\n", + "x_val.shape = torch.Size([200, 1, 28, 28])\n", + "image_shape = torch.Size([1, 28, 28])\n" + ] + } + ], + "execution_count": 1 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-08-13T17:20:06.058329Z", + "start_time": "2024-08-13T17:20:05.891695Z" + } + }, + "cell_type": "code", + "source": [ + "from torchflows.flows import Flow\n", + "from torchflows.architectures import RealNVP, MultiscaleRealNVP\n", + "\n", + "real_nvp = Flow(RealNVP(image_shape))\n", + "multiscale_real_nvp = Flow(MultiscaleRealNVP(image_shape))" + ], + "id": "744513899ffa6a46", + "outputs": [], + "execution_count": 2 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-08-13T17:26:11.651540Z", + "start_time": "2024-08-13T17:20:06.378393Z" + } + }, + "cell_type": "code", + "source": [ + "real_nvp.fit(x_train, x_val=x_val, early_stopping=True, show_progress=True)\n", + "multiscale_real_nvp.fit(x_train, x_val=x_val, early_stopping=True, show_progress=True)" + ], + "id": "7a439e2565ce5a25", + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting NF: 30%|███ | 151/500 [00:18<00:42, 8.30it/s, Training loss (batch): -0.2608, Validation loss: 1.3448 [best: 0.1847 @ 100]] \n", + "Fitting NF: 30%|███ | 152/500 [05:47<13:14, 2.28s/it, Training loss (batch): -0.3050, Validation loss: 0.9754 [best: 0.1744 @ 101]] \n" + ] + } + ], + "execution_count": 3 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-08-13T17:26:11.699539Z", + "start_time": "2024-08-13T17:26:11.686539Z" + } + }, + "cell_type": "code", + "source": "", + "id": "c38fc6cc58bdc0b2", + "outputs": [], + "execution_count": null + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/notebooks/modifying_architectures.ipynb b/docs/notebooks/modifying_architectures.ipynb new file mode 100644 index 0000000..57e8888 --- /dev/null +++ b/docs/notebooks/modifying_architectures.ipynb @@ -0,0 +1,95 @@ +{ + "cells": [ + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "# Creating and modifying bijection architectures\n", + "\n", + "We give an example on how to modify a bijection's architecture.\n", + "We use the Masked Autoregressive Flow (MAF) as an example.\n", + "We can manually set the number of invertible layers as follows:" + ], + "id": "816b6834787d3345" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-08-13T16:36:31.907537Z", + "start_time": "2024-08-13T16:36:30.468390Z" + } + }, + "cell_type": "code", + "source": [ + "from torchflows.architectures import MAF\n", + "\n", + "event_shape = (10,)\n", + "architecture = MAF(event_shape=event_shape, n_layers=5)" + ], + "id": "66ac0baadcdbc9e7", + "outputs": [], + "execution_count": 1 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "For specific changes, we can create individual invertible layers and combine them into a bijection.\n", + "MAF uses affine masked autoregressive layers with permutations in between.\n", + "We can import these layers set their parameters as desired.\n", + "For example, to change the number of layers in the MAF conditioner and its hidden layer sizes, we proceed as follows:\n" + ], + "id": "55ca1607131cabe" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-08-13T16:36:31.922917Z", + "start_time": "2024-08-13T16:36:31.912398Z" + } + }, + "cell_type": "code", + "source": [ + "from torchflows.bijections import BijectiveComposition\n", + "from torchflows.bijections.finite.autoregressive.layers import AffineForwardMaskedAutoregressive\n", + "from torchflows.bijections.finite.linear import ReversePermutation\n", + "\n", + "event_shape = (10,)\n", + "architecture = BijectiveComposition(\n", + " event_shape=event_shape,\n", + " layers=[\n", + " AffineForwardMaskedAutoregressive(event_shape=event_shape, n_layers=4, n_hidden=20),\n", + " ReversePermutation(event_shape=event_shape),\n", + " AffineForwardMaskedAutoregressive(event_shape=event_shape, n_layers=3, n_hidden=7),\n", + " ReversePermutation(event_shape=event_shape),\n", + " AffineForwardMaskedAutoregressive(event_shape=event_shape, n_layers=5, n_hidden=13)\n", + " ]\n", + ")" + ], + "id": "6c3cd341625f2ee4", + "outputs": [], + "execution_count": 2 + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/notebooks/training_with_datasets.ipynb b/docs/notebooks/training_with_datasets.ipynb new file mode 100644 index 0000000..b6ea860 --- /dev/null +++ b/docs/notebooks/training_with_datasets.ipynb @@ -0,0 +1,153 @@ +{ + "cells": [ + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "# Training a normalizing flow\n", + "\n", + "This notebook explores how we can use Torchflows to train a normalizing flow given a dataset.\n", + "\n", + "## Basic training\n", + "In the cell below, we generate a synthetic dataset of 50-dimensional vectors. We then create a RealNVP model and fit it to the dataset. " + ], + "id": "6affa6cc0fccc1fe" + }, + { + "cell_type": "code", + "id": "initial_id", + "metadata": { + "collapsed": true, + "ExecuteTime": { + "end_time": "2024-08-13T16:17:28.856450Z", + "start_time": "2024-08-13T16:17:18.459461Z" + } + }, + "source": [ + "import torch\n", + "from torchflows.flows import Flow\n", + "from torchflows.architectures import RealNVP\n", + "\n", + "torch.manual_seed(0) # random seed for reproducibility\n", + "event_shape = (50,) # shape of data points\n", + "x_train = torch.randn(1000, *event_shape) * 5 + 7 # generate the dataset\n", + "flow = Flow(RealNVP(event_shape=event_shape)) # create the flow\n", + "flow.fit(x_train, show_progress=True) # train the flow" + ], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting NF: 100%|██████████| 500/500 [00:08<00:00, 59.25it/s, Training loss (batch): 3.0914]\n" + ] + } + ], + "execution_count": 1 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "## Early stopping with validation data\n", + "\n", + "If we have access to a validation set, we can automatically stop training when validation loss stops decreasing. In the cell below, we stop training when the validation loss has not decreased for 50 consecutive training steps." + ], + "id": "5e24490fe6ec39d3" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-08-13T16:18:44.066344Z", + "start_time": "2024-08-13T16:17:28.865435Z" + } + }, + "cell_type": "code", + "source": [ + "torch.manual_seed(0)\n", + "x_val = torch.randn(200, *event_shape) * 5 + 7\n", + "flow = Flow(RealNVP(event_shape=event_shape))\n", + "flow.fit(x_train, x_val=x_val, early_stopping=True, early_stopping_threshold=50, show_progress=True, n_epochs=10000)" + ], + "id": "5bb26f3529695c1c", + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting NF: 32%|███▎ | 3250/10000 [01:15<02:36, 43.23it/s, Training loss (batch): 3.0279, Validation loss: 3.0294 [best: 3.0294 @ 3199]]\n" + ] + } + ], + "execution_count": 2 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "## Visualize the results\n", + "We create a scatterplot to see if the train flow matches the training data. We draw 10000 samples from the trained flow." + ], + "id": "7d131c2fdef21efb" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-08-13T16:19:29.717822Z", + "start_time": "2024-08-13T16:19:29.450373Z" + } + }, + "cell_type": "code", + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "torch.manual_seed(0)\n", + "x_flow = flow.sample((10000,)).detach()\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.scatter(x_flow[:, 0], x_flow[:, 1], label='Flow samples', s=5)\n", + "ax.scatter(x_train[:, 0], x_train[:, 1], label='Training data', s=10)\n", + "ax.legend()\n", + "ax.set_xlabel('Dimension 0')\n", + "ax.set_ylabel('Dimension 1')\n", + "fig.tight_layout()\n", + "plt.show()" + ], + "id": "860c91f05f91b8b0", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 9 + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/notebooks/training_with_variational_inference.ipynb b/docs/notebooks/training_with_variational_inference.ipynb new file mode 100644 index 0000000..134cec7 --- /dev/null +++ b/docs/notebooks/training_with_variational_inference.ipynb @@ -0,0 +1,162 @@ +{ + "cells": [ + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "# Training a normalizing flow with stochastic variational inference\n", + "\n", + "This notebook explores how we can use Torchflows to train a normalizing flow given an unnormalized log probability density function.\n", + "\n", + "We first define the log density as a torch function. In this example, we use a 11-dimensional diagonal Gaussian with mean 5 and standard deviation 2 in each dimension." + ], + "id": "d7ac019be7bff9c9" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-08-13T16:33:18.692813Z", + "start_time": "2024-08-13T16:33:17.261139Z" + } + }, + "cell_type": "code", + "source": [ + "import torch\n", + "\n", + "n_dim = 11\n", + "mean = 5\n", + "std = 2\n", + "\n", + "\n", + "def log_density(x):\n", + " \"\"\"\n", + " :param x: input data with shape (*batch_shape, n_dim)\n", + " \"\"\"\n", + " return -0.5 * torch.sum((x - mean) ** 2 / std ** 2, dim=-1)" + ], + "id": "6cdc95a329248401", + "outputs": [], + "execution_count": 1 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "We now create the flow object. We use a Masked Autoregressive Flow. In each training epoch, we estimate the variational loss with a single sample. We stop the training after 500 epochs of no decrease in loss value. ", + "id": "78b2963e2fcc8a8c" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-08-13T16:33:26.094518Z", + "start_time": "2024-08-13T16:33:18.700717Z" + } + }, + "cell_type": "code", + "source": [ + "from torchflows.flows import Flow\n", + "from torchflows.architectures import RealNVP\n", + "\n", + "torch.manual_seed(0)\n", + "flow = Flow(RealNVP(event_shape=(n_dim,)))\n", + "flow.variational_fit(target_log_prob=log_density, show_progress=True, n_epochs=5000, n_samples=1, early_stopping=True, early_stopping_threshold=500)" + ], + "id": "52bea404b1a76fab", + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting with SVI: 28%|██▊ | 1383/5000 [00:06<00:17, 202.55it/s, Loss: 7.9173 [best: 4.6283 @ 882]] \n" + ] + } + ], + "execution_count": 2 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "## Visualize the results\n", + "We create a scatterplot to see if the train flow matches the true distribution. This is possible because we used a synthetic target log density. We draw 10000 samples from the trained flow." + ], + "id": "c0f0b2bc84c6486e" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-08-13T16:33:26.839718Z", + "start_time": "2024-08-13T16:33:26.236455Z" + } + }, + "cell_type": "code", + "source": [ + "import matplotlib.pyplot as plt\n", + "from matplotlib.patches import Ellipse\n", + "\n", + "torch.manual_seed(0)\n", + "x_flow = flow.sample((10000,)).detach()\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.scatter(x_flow[:, 0], x_flow[:, 1], label='Flow samples', s=5, alpha=0.4)\n", + "ax.add_patch(Ellipse(xy=(5, 5), height=1 * std, width=1 * std, fc='none', color='tab:orange', linewidth=2))\n", + "ax.add_patch(Ellipse(xy=(5, 5), height=2 * std, width=2 * std, fc='none', color='tab:orange', linewidth=2))\n", + "ax.add_patch(Ellipse(xy=(5, 5), height=3 * std, width=3 * std, fc='none', color='tab:orange', linewidth=2,\n", + " label='Ground truth contours'))\n", + "ax.legend()\n", + "ax.set_xlabel('Dimension 0')\n", + "ax.set_ylabel('Dimension 1')\n", + "ax.axis('equal')\n", + "fig.tight_layout()\n", + "plt.show()" + ], + "id": "8b99d6856bbab5c4", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 3 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-08-13T16:33:26.871372Z", + "start_time": "2024-08-13T16:33:26.857349Z" + } + }, + "cell_type": "code", + "source": "", + "id": "3c15079bad2c0ba9", + "outputs": [], + "execution_count": null + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/requirements.txt b/docs/requirements.txt index 1d628f2..2c4c704 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -1,2 +1,5 @@ sphinx==7.1.2 -sphinx-rtd-theme==1.3.0rc1 \ No newline at end of file +sphinx-rtd-theme==1.3.0rc1 +torchflows>=1.0.2 +sphinx-copybutton +nbsphinx \ No newline at end of file diff --git a/docs/source/api.rst b/docs/source/api.rst deleted file mode 100644 index ef16c97..0000000 --- a/docs/source/api.rst +++ /dev/null @@ -1,7 +0,0 @@ -API -=== - -.. autosummary:: - :toctree: generated - - torchflows \ No newline at end of file diff --git a/docs/source/api/architectures.rst b/docs/source/api/architectures.rst new file mode 100644 index 0000000..73b9613 --- /dev/null +++ b/docs/source/api/architectures.rst @@ -0,0 +1,38 @@ +Standard architectures +============================ +We lists notable implemented bijection architectures. +These all inherit from the Bijection class. + +.. _architectures: + +Autoregressive architectures +-------------------------------- + +.. autoclass:: torchflows.architectures.RealNVP +.. autoclass:: torchflows.architectures.InverseRealNVP +.. autoclass:: torchflows.architectures.NICE +.. autoclass:: torchflows.architectures.MAF +.. autoclass:: torchflows.architectures.IAF +.. autoclass:: torchflows.architectures.CouplingRQNSF +.. autoclass:: torchflows.architectures.MaskedAutoregressiveRQNSF +.. autoclass:: torchflows.architectures.InverseAutoregressiveRQNSF +.. autoclass:: torchflows.architectures.CouplingLRS +.. autoclass:: torchflows.architectures.MaskedAutoregressiveLRS +.. autoclass:: torchflows.architectures.CouplingDSF +.. autoclass:: torchflows.architectures.UMNNMAF + +Continuous architectures +------------------------- +.. autoclass:: torchflows.architectures.DeepDiffeomorphicBijection +.. autoclass:: torchflows.architectures.RNODE +.. autoclass:: torchflows.architectures.FFJORD +.. autoclass:: torchflows.architectures.OTFlow + +Residual architectures +----------------------- +.. autoclass:: torchflows.architectures.ResFlow +.. autoclass:: torchflows.architectures.ProximalResFlow +.. autoclass:: torchflows.architectures.InvertibleResNet +.. autoclass:: torchflows.architectures.PlanarFlow +.. autoclass:: torchflows.architectures.RadialFlow +.. autoclass:: torchflows.architectures.SylvesterFlow \ No newline at end of file diff --git a/docs/source/api/base_distributions.rst b/docs/source/api/base_distributions.rst new file mode 100644 index 0000000..174ba1e --- /dev/null +++ b/docs/source/api/base_distributions.rst @@ -0,0 +1,14 @@ +Base distribution objects +========================== + +.. autoclass:: torchflows.base_distributions.gaussian.DiagonalGaussian + :members: __init__ + +.. autoclass:: torchflows.base_distributions.gaussian.DenseGaussian + :members: __init__ + +.. autoclass:: torchflows.base_distributions.mixture.DiagonalGaussianMixture + :members: __init__ + +.. autoclass:: torchflows.base_distributions.mixture.DenseGaussianMixture + :members: __init__ diff --git a/docs/source/api/bijections.rst b/docs/source/api/bijections.rst new file mode 100644 index 0000000..2be7d28 --- /dev/null +++ b/docs/source/api/bijections.rst @@ -0,0 +1,24 @@ +Bijection objects +==================== + +All normalizing flow transformations are bijections. +The following classes define forward and inverse pass methods which all flow architectures inherit. + +.. autoclass:: torchflows.bijections.base.Bijection + :members: __init__, forward, inverse + +.. autoclass:: torchflows.bijections.base.BijectiveComposition + :members: __init__ + +.. autoclass:: torchflows.bijections.continuous.base.ContinuousBijection + :members: __init__, forward, inverse + +.. autoclass:: torchflows.bijections.finite.multiscale.base.MultiscaleBijection + :members: __init__ + +Inverting a bijection +--------------------- + +Each bijection can be inverted with the `invert` function. + +.. autofunction:: torchflows.bijections.base.invert \ No newline at end of file diff --git a/docs/source/api/components.rst b/docs/source/api/components.rst new file mode 100644 index 0000000..a84b33e --- /dev/null +++ b/docs/source/api/components.rst @@ -0,0 +1,7 @@ +Model components +=================== + +.. toctree:: + base_distributions + bijections + flow diff --git a/docs/source/api/flow.rst b/docs/source/api/flow.rst new file mode 100644 index 0000000..0fe1d1d --- /dev/null +++ b/docs/source/api/flow.rst @@ -0,0 +1,14 @@ +Flow objects +=============================== +The `Flow` object contains a base distribution and a bijection. + +.. _flow: + +.. autoclass:: torchflows.flows.BaseFlow + :members: regularization, fit, variational_fit + +.. autoclass:: torchflows.flows.Flow + :members: __init__, forward_with_log_prob, log_prob, sample + +.. autoclass:: torchflows.flows.FlowMixture + :members: __init__, log_prob, sample \ No newline at end of file diff --git a/docs/source/api/multiscale_architectures.rst b/docs/source/api/multiscale_architectures.rst new file mode 100644 index 0000000..b74d185 --- /dev/null +++ b/docs/source/api/multiscale_architectures.rst @@ -0,0 +1,11 @@ +Multiscale architectures +======================================================== + +Multiscale architectures are suitable for image modeling. + +.. _multiscale_architectures: + +.. autoclass:: torchflows.architectures.MultiscaleRealNVP +.. autoclass:: torchflows.architectures.MultiscaleRQNSF +.. autoclass:: torchflows.architectures.MultiscaleLRSNSF +.. autoclass:: torchflows.architectures.MultiscaleNICE diff --git a/docs/source/conf.py b/docs/source/conf.py new file mode 100644 index 0000000..bc399a8 --- /dev/null +++ b/docs/source/conf.py @@ -0,0 +1,35 @@ +# Configuration file for the Sphinx documentation builder. +# +# For the full list of built-in configuration values, see the documentation: +# https://www.sphinx-doc.org/en/master/usage/configuration.html + +# -- Project information ----------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information +import pathlib +import sys + +sys.path.insert(0, pathlib.Path(__file__).parents[2].resolve().as_posix()) + +project = 'Torchflows' +copyright = '2024, David Nabergoj' +author = 'David Nabergoj' +release = '1.0.2' + +# -- General configuration --------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration + +extensions = [ + 'sphinx.ext.duration', + 'sphinx.ext.doctest', + 'sphinx.ext.autodoc', + 'sphinx.ext.autosummary', + 'sphinx_copybutton', +] + +exclude_patterns = [] + +# -- Options for HTML output ------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output + +html_theme = 'sphinx_rtd_theme' +epub_show_urls = 'footnote' diff --git a/docs/source/guides/basic_usage.rst b/docs/source/guides/basic_usage.rst new file mode 100644 index 0000000..9612bad --- /dev/null +++ b/docs/source/guides/basic_usage.rst @@ -0,0 +1,45 @@ +Basic usage +============== + +All Torchflow models are constructed as a combination of a bijection and a base distribution. +Both the bijection and base distribution objects work on events (tensors) with a set event shape. +A bijection and a distribution instance are are packaged together into a `Flow` object, creating a trainable torch module. +The simplest way to create a normalizing flow is to import an existing architecture and wrap it with a `Flow` object. +In the example below, we use the Real NVP architecture. +We do not specify a base distribution, so the default standard Gaussian is chosen. + +.. code-block:: python + + from torchflows.flows import Flow + from torchflows.architectures import RealNVP + + event_shape = (10,) # suppose our data are 10-dimensional vectors + flow = Flow(RealNVP(event_shape)) + +Normalizing flows learn the distributions of unlabeled data. +We provide an example on how to train a flow for a dataset of 50-dimensional vectors. + +.. code-block:: python + + import torch + from torchflows.flows import Flow + from torchflows.architectures import RealNVP + + torch.manual_seed(0) + + n_data = 1000 + n_dim = 50 + + x = torch.randn(n_data, n_dim) # Generate synthetic training data + flow = Flow(RealNVP(n_dim)) # Create the normalizing flow + flow.fit(x, show_progress=True) # Fit the normalizing flow to training data + +After fitting the flow, we can use it to sample new data and compute the log probability density of data points. + +.. code-block:: python + + x_new = flow.sample(50) # Sample 50 new data points + print(x_new.shape) # (50, 3) + + log_prob = flow.log_prob(x) # Compute the data log probability + print(log_prob.shape) # (100,) diff --git a/docs/source/guides/choosing_base_distributions.rst b/docs/source/guides/choosing_base_distributions.rst new file mode 100644 index 0000000..bc9e472 --- /dev/null +++ b/docs/source/guides/choosing_base_distributions.rst @@ -0,0 +1,51 @@ +Choosing a base distribution +============================== + +We may replace the default standard Gaussian distribution with any torch distribution that is also a module. +Some custom distributions are already implemented. +We show an example for a diagonal Gaussian base distribution with mean 3 and standard deviation 2. + +.. code-block:: python + + import torch + from torchflows.flows import Flow + from torchflows.architectures import RealNVP + from torchflows.base_distributions.gaussian import DiagonalGaussian + + torch.manual_seed(0) + event_shape = (10,) + base_distribution = DiagonalGaussian( + loc=torch.full(size=event_shape, fill_value=3.0), + scale=torch.full(size=event_shape, fill_value=2.0), + ) + flow = Flow(RealNVP(event_shape), base_distribution=base_distribution) + + x_new = flow.sample((10,)) + +Nontrivial event shapes +------------------------ + +When the event has more than one axis, the base distribution must deal with flattened data. We show an example below. + +.. note:: + + The requirement to work with flattened data may change in the future. + + +.. code-block:: python + + import torch + from torchflows.flows import Flow + from torchflows.architectures import RealNVP + from torchflows.base_distributions.gaussian import DiagonalGaussian + + torch.manual_seed(0) + event_shape = (2, 3, 5) + event_size = int(torch.prod(torch.as_tensor(event_shape))) + base_distribution = DiagonalGaussian( + loc=torch.full(size=(event_size,), fill_value=3.0), + scale=torch.full(size=(event_size,), fill_value=2.0), + ) + flow = Flow(RealNVP(event_shape), base_distribution=base_distribution) + + x_new = flow.sample((10,)) diff --git a/docs/source/guides/cuda.rst b/docs/source/guides/cuda.rst new file mode 100644 index 0000000..84e3009 --- /dev/null +++ b/docs/source/guides/cuda.rst @@ -0,0 +1,18 @@ +Using CUDA +=========== + +Torchflows models are torch modules and thus seamlessly support CUDA (and other devices). +When using the *fit* method, training data is automatically transferred onto the flow device. + +.. code-block:: python + + import torch + from torchflows.flows import Flow + from torchflows.architectures import RealNVP + + torch.manual_seed(0) + event_shape = (10,) + x_train = torch.randn(size=(1000, *event_shape)) + + flow = Flow(RealNVP(event_shape)).cuda() + flow.fit(x_train, show_progress=True) \ No newline at end of file diff --git a/docs/source/guides/event_shapes.rst b/docs/source/guides/event_shapes.rst new file mode 100644 index 0000000..e2a62d3 --- /dev/null +++ b/docs/source/guides/event_shapes.rst @@ -0,0 +1,22 @@ +Event shapes +====================== + +Torchflows supports modeling tensors with arbitrary shapes. For example, we can model events with shape `(2, 3, 5)` as follows: + +.. code-block:: python + + import torch + from torchflows.flows import Flow + from torchflows.architectures import RealNVP + + torch.manual_seed(0) + event_shape = (2, 3, 5) + n_data = 1000 + x_train = torch.randn(size=(n_data, *event_shape)) + print(x_train.shape) # (1000, 2, 3, 5) + + flow = Flow(RealNVP(event_shape)) + flow.fit(x_train, show_progress=True) + + x_new = flow.sample((500,)) + print(x_new.shape) # (500, 2, 3, 5) \ No newline at end of file diff --git a/docs/source/guides/image_modeling.rst b/docs/source/guides/image_modeling.rst new file mode 100644 index 0000000..757365e --- /dev/null +++ b/docs/source/guides/image_modeling.rst @@ -0,0 +1,22 @@ +Image modeling +============== + +When modeling images, we can use specialized multiscale architectures which use convolutional neural network conditioners and specialized coupling schemes. +These architectures expect event shapes to be *(channels, height, width)*. + +.. note:: + Multiscale architectures are currently undergoing improvements. + +.. code-block:: python + + import torch + from torchflows.flows import Flow + from torchflows.architectures import MultiscaleRealNVP + + image_shape = (3, 28, 28) + n_images = 100 + + torch.manual_seed(0) + training_images = torch.randn(size=(n_images, *image_shape)) # synthetic data + flow = Flow(MultiscaleRealNVP(image_shape)) + flow.fit(training_images, show_progress=True) \ No newline at end of file diff --git a/docs/source/guides/installing.rst b/docs/source/guides/installing.rst new file mode 100644 index 0000000..ded9336 --- /dev/null +++ b/docs/source/guides/installing.rst @@ -0,0 +1,30 @@ +Installing +============================ + +.. _installing: + +.. note:: + + Torchflows supports Python versions 3.7 and upwards. + +We provide several options to install Torchflows. + +Install the latest stable version from PyPI: + +.. code-block:: console + + pip install torchflows + +Install the latest version from Github: + +.. code-block:: + + pip install git+https://github.com/davidnabergoj/torchflows.git + +Install Torchflows for development: + +.. code-block:: + + git clone https://github.com/davidnabergoj/torchflows.git + cd torchflows + pip install -r requirements.txt diff --git a/docs/source/guides/mathematical_background.rst b/docs/source/guides/mathematical_background.rst new file mode 100644 index 0000000..cb4dd94 --- /dev/null +++ b/docs/source/guides/mathematical_background.rst @@ -0,0 +1,16 @@ +What is a normalizing flow +========================== + +A normalizing flow (NF) is a flexible trainable distribution. +It is defined as a bijective transformation of a simple distribution, such as a standard Gaussian. +The bijection is typically an invertible neural network. +Training a NF using a dataset means optimizing the bijection's parameters to make the dataset likely under the NF. +We can use a NF to compute the probability of a data point or to independently sample data from the process that +generated our dataset. + +The density of a NF :math:`q(x)` with the bijection :math:`f(z) = x` and base distribution :math:`p(z)` is defined as: + +.. math:: + \log q(x) = \log p(f^{-1}(x)) + \log\left|\det J_{f^{-1}}(x)\right|. + +Sampling from a NF means sampling from the simple distribution and transforming the sample using the bijection. diff --git a/docs/source/guides/tutorial.rst b/docs/source/guides/tutorial.rst new file mode 100644 index 0000000..f9f63b1 --- /dev/null +++ b/docs/source/guides/tutorial.rst @@ -0,0 +1,13 @@ +Tutorial +=========== + +We provide tutorials and notebooks for typical Torchflows use cases. + +.. toctree:: + + mathematical_background + basic_usage + event_shapes + image_modeling + choosing_base_distributions + cuda diff --git a/docs/source/index.rst b/docs/source/index.rst index 25d73c9..d2f9b46 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -1,5 +1,10 @@ -Welcome to Torchflows documentation! -=================================== +.. Torchflows documentation master file, created by + sphinx-quickstart on Tue Aug 13 19:59:47 2024. + You can adapt this file completely to your liking, but it should at least + contain the root `toctree` directive. + +Torchflows documentation +======================== Torchflows is a library for generative modeling and density estimation using normalizing flows. It implements many normalizing flow architectures and their building blocks for: @@ -7,17 +12,34 @@ It implements many normalizing flow architectures and their building blocks for: * easy use of normalizing flows as trainable distributions; * easy implementation of new normalizing flows. -Check out the :doc:`usage` section for further information, including -how to :ref:`installation` the project. +Torchflows is structured according to the review paper `Normalizing Flows for Probabilistic Modeling and Inference <(https://arxiv.org/abs/1912.02762)>`_ by Papamakarios et al. (2021), which classifies flow architectures as autoregressive, residual, or continuous. +Visit the `Github page `_ to keep up to date and post any questions or issues `here `_. + +Installing +--------------- +Torchflows can be installed easily using pip: + +.. code-block:: console + + pip install torchflows -.. note:: +For other install options, see the :ref:`install ` section. - This project is under active development. +Guides +========= -Contents --------- +.. toctree:: + + guides/installing + guides/tutorial + +API +==== .. toctree:: + :maxdepth: 3 + + api/components + api/architectures + api/multiscale_architectures - usage - api \ No newline at end of file diff --git a/docs/source/usage.rst b/docs/source/usage.rst deleted file mode 100644 index 86a0870..0000000 --- a/docs/source/usage.rst +++ /dev/null @@ -1,13 +0,0 @@ -Usage -===== - -.. _installation: - -Installation ------------- - -To use Torchflows, first install it using pip: - -.. code-block:: console - - (.venv) $ pip install torchflows diff --git a/test/test_autograd_bijections.py b/test/test_autograd_bijections.py index bbd84bb..e609a6e 100644 --- a/test/test_autograd_bijections.py +++ b/test/test_autograd_bijections.py @@ -4,12 +4,13 @@ import torch from torchflows import Flow -from torchflows.bijections import LU, ReversePermutation, LowerTriangular, \ - Orthogonal, QR, ElementwiseScale, LRSCoupling, LinearRQSCoupling -from torchflows.bijections import RealNVP, MAF, CouplingRQNSF, MaskedAutoregressiveRQNSF, ResFlowBlock, \ - InvertibleResNetBlock, \ - ElementwiseAffine, ElementwiseShift, InverseAutoregressiveRQNSF, IAF, NICE from torchflows.bijections.base import Bijection +from torchflows.bijections.finite.autoregressive.architectures import NICE, RealNVP, CouplingRQNSF, MAF, IAF, \ + InverseAutoregressiveRQNSF, MaskedAutoregressiveRQNSF +from torchflows.bijections.finite.autoregressive.layers import ElementwiseScale, ElementwiseAffine, ElementwiseShift, \ + LRSCoupling, LinearRQSCoupling +from torchflows.bijections.finite.linear import LU, ReversePermutation, LowerTriangular, Orthogonal, QR +from torchflows.bijections.finite.residual.iterative import InvertibleResNetBlock, ResFlowBlock from torchflows.bijections.finite.residual.planar import Planar from torchflows.bijections.finite.residual.radial import Radial from torchflows.bijections.finite.residual.sylvester import Sylvester diff --git a/test/test_cuda.py b/test/test_cuda.py index 59713b5..888a08f 100644 --- a/test/test_cuda.py +++ b/test/test_cuda.py @@ -1,10 +1,9 @@ import pytest import torch -from torchflows.bijections import RealNVP from torchflows import Flow +from torchflows.bijections.finite.autoregressive.architectures import RealNVP -@pytest.mark.skip(reason="Too slow on CI/CD") def test_real_nvp_log_prob_data_on_cpu(): if not torch.cuda.is_available(): pytest.skip("CUDA not available") @@ -20,7 +19,6 @@ def test_real_nvp_log_prob_data_on_cpu(): flow.log_prob(x_train) -@pytest.mark.skip(reason="Too slow on CI/CD") def test_real_nvp_log_prob_data_on_gpu(): if not torch.cuda.is_available(): pytest.skip("CUDA not available") @@ -36,7 +34,6 @@ def test_real_nvp_log_prob_data_on_gpu(): flow.log_prob(x_train.cuda()) -@pytest.mark.skip(reason="Too slow on CI/CD") def test_real_nvp_fit_data_on_cpu(): if not torch.cuda.is_available(): pytest.skip("CUDA not available") @@ -49,10 +46,9 @@ def test_real_nvp_fit_data_on_cpu(): x_train = torch.randn(*batch_shape, *event_shape) flow = Flow(RealNVP(event_shape)).cuda() - flow.fit(x_train) + flow.fit(x_train, n_epochs=3) -@pytest.mark.skip(reason="Too slow on CI/CD") def test_real_nvp_fit_data_on_gpu(): if not torch.cuda.is_available(): pytest.skip("CUDA not available") @@ -65,4 +61,4 @@ def test_real_nvp_fit_data_on_gpu(): x_train = torch.randn(*batch_shape, *event_shape) flow = Flow(RealNVP(event_shape)).cuda() - flow.fit(x_train.cuda()) + flow.fit(x_train.cuda(), n_epochs=3) diff --git a/test/test_fit.py b/test/test_fit.py index bfa29ba..0a80100 100644 --- a/test/test_fit.py +++ b/test/test_fit.py @@ -1,9 +1,12 @@ import pytest import torch from torchflows import Flow -from torchflows.bijections import NICE, RealNVP, MAF, ElementwiseAffine, ElementwiseShift, ElementwiseRQSpline, \ - CouplingRQNSF, MaskedAutoregressiveRQNSF, LowerTriangular, ElementwiseScale, QR, LU from test.constants import __test_constants +from torchflows.bijections.finite.autoregressive.architectures import NICE, RealNVP, MAF, CouplingRQNSF, \ + MaskedAutoregressiveRQNSF +from torchflows.bijections.finite.autoregressive.layers import ElementwiseScale, ElementwiseAffine, ElementwiseShift, \ + ElementwiseRQSpline +from torchflows.bijections.finite.linear import LowerTriangular, LU, QR @pytest.mark.skip(reason='Takes too long, fit quality is architecture-dependent') diff --git a/test/test_reconstruction_bijections.py b/test/test_reconstruction_bijections.py index 66d9086..dbb2b8f 100644 --- a/test/test_reconstruction_bijections.py +++ b/test/test_reconstruction_bijections.py @@ -3,18 +3,19 @@ import pytest import torch -from torchflows.bijections import LU, ReversePermutation, LowerTriangular, \ - Orthogonal, QR, ElementwiseScale, LRSCoupling, LinearRQSCoupling -from torchflows.bijections import RealNVP, MAF, CouplingRQNSF, MaskedAutoregressiveRQNSF, ResFlowBlock, \ - InvertibleResNetBlock, \ - ElementwiseAffine, ElementwiseShift, InverseAutoregressiveRQNSF, IAF, NICE -from torchflows.bijections import FFJORD + from torchflows.bijections.continuous.base import ContinuousBijection, ExactODEFunction from torchflows.bijections.base import Bijection -from torchflows.bijections.continuous.ddnf import DeepDiffeomorphicBijection +from torchflows.bijections.continuous.ffjord import FFJORD from torchflows.bijections.continuous.otflow import OTFlow from torchflows.bijections.continuous.rnode import RNODE +from torchflows.bijections.finite.autoregressive.architectures import NICE, RealNVP, CouplingRQNSF, MAF, IAF, \ + InverseAutoregressiveRQNSF, MaskedAutoregressiveRQNSF +from torchflows.bijections.finite.autoregressive.layers import ElementwiseScale, ElementwiseAffine, ElementwiseShift, \ + LRSCoupling, LinearRQSCoupling +from torchflows.bijections.finite.linear import LU, ReversePermutation, LowerTriangular, Orthogonal, QR from torchflows.bijections.finite.residual.architectures import ResFlow, InvertibleResNet, ProximalResFlow +from torchflows.bijections.finite.residual.iterative import InvertibleResNetBlock, ResFlowBlock from torchflows.bijections.finite.residual.planar import Planar from torchflows.bijections.finite.residual.proximal import ProximalResFlowBlock from torchflows.bijections.finite.residual.radial import Radial diff --git a/test/test_sample.py b/test/test_sample.py index 68a3bac..24c9060 100644 --- a/test/test_sample.py +++ b/test/test_sample.py @@ -1,7 +1,7 @@ import torch from torchflows import Flow -from torchflows.bijections import RealNVP +from torchflows.bijections.finite.autoregressive.architectures import RealNVP def test_real_nvp(): diff --git a/test/test_sigmoid_transformer.py b/test/test_sigmoid_transformer.py index eb9aa71..d7e7826 100644 --- a/test/test_sigmoid_transformer.py +++ b/test/test_sigmoid_transformer.py @@ -2,7 +2,8 @@ import torch from torchflows import Flow -from torchflows.bijections import DSCoupling, CouplingDSF +from torchflows.bijections.finite.autoregressive.architectures import CouplingDSF +from torchflows.bijections.finite.autoregressive.layers import DSCoupling from torchflows.bijections.finite.autoregressive.transformers.combination.sigmoid import Sigmoid, DeepSigmoid from torchflows.bijections.base import invert from test.constants import __test_constants diff --git a/torchflows/__init__.py b/torchflows/__init__.py index 539e9dc..6d3802c 100644 --- a/torchflows/__init__.py +++ b/torchflows/__init__.py @@ -1,5 +1,5 @@ from torchflows.flows import Flow, FlowMixture -from torchflows.bijections import ( +from torchflows.bijections.finite.autoregressive.architectures import ( NICE, RealNVP, InverseRealNVP, @@ -8,25 +8,48 @@ CouplingRQNSF, InverseAutoregressiveRQNSF, MaskedAutoregressiveRQNSF, - FFJORD, - DeepDiffeomorphicBijection, - OTFlow, - RNODE, - InvertibleResNetBlock, - ResFlowBlock, - ProximalResFlowBlock, - InvertibleResNet, +) +from torchflows.bijections.finite.residual.architectures import ( ResFlow, ProximalResFlow, - QuasiAutoregressiveFlowBlock, - Radial, + InvertibleResNet, Planar, - InversePlanar, + Radial, Sylvester, - IdentitySylvester, - HouseholderSylvester, - PermutationSylvester, +) +from torchflows.bijections.finite.autoregressive.layers import ( ElementwiseShift, ElementwiseAffine, - ElementwiseRQSpline + ElementwiseRQSpline, + ElementwiseScale ) +from torchflows.bijections.continuous.rnode import RNODE +from torchflows.bijections.continuous.ffjord import FFJORD +from torchflows.bijections.continuous.ddnf import DeepDiffeomorphicBijection +from torchflows.bijections.continuous.otflow import OTFlow + +__all__ = [ + 'NICE', + 'RealNVP', + 'InverseRealNVP', + 'MAF', + 'IAF', + 'CouplingRQNSF', + 'InverseAutoregressiveRQNSF', + 'MaskedAutoregressiveRQNSF', + 'FFJORD', + 'DeepDiffeomorphicBijection', + 'OTFlow', + 'RNODE', + 'InvertibleResNet', + 'ResFlow', + 'ProximalResFlow', + 'Radial', + 'Planar', + 'Sylvester', + 'ElementwiseShift', + 'ElementwiseAffine', + 'ElementwiseRQSpline', + 'Flow', + 'FlowMixture', +] diff --git a/torchflows/architectures.py b/torchflows/architectures.py index d0c59f6..265c842 100644 --- a/torchflows/architectures.py +++ b/torchflows/architectures.py @@ -1,6 +1,7 @@ from torchflows.bijections.finite.autoregressive.architectures import ( NICE, RealNVP, + InverseRealNVP, MAF, IAF, CouplingRQNSF, @@ -21,9 +22,9 @@ ResFlow, ProximalResFlow, InvertibleResNet, - Planar, - Radial, - Sylvester + PlanarFlow, + RadialFlow, + SylvesterFlow ) from torchflows.bijections.finite.multiscale.architectures import ( diff --git a/torchflows/base_distributions/__init__.py b/torchflows/base_distributions/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/torchflows/base_distributions/gaussian.py b/torchflows/base_distributions/gaussian.py index bc37342..9ce1764 100644 --- a/torchflows/base_distributions/gaussian.py +++ b/torchflows/base_distributions/gaussian.py @@ -6,12 +6,22 @@ class DiagonalGaussian(torch.distributions.Distribution, nn.Module): + """Diagonal Gaussian distribution. Extends torch.distributions.Distribution and torch.nn.Module. + """ def __init__(self, loc: torch.Tensor, scale: torch.Tensor, trainable_loc: bool = False, trainable_scale: bool = False): - super().__init__(event_shape=loc.shape) + """ + DiagonalGaussian constructor. + + :param torch.Tensor loc: location vector with shape `(event_size,)`. + :param torch.Tensor scale: scale vector with shape `(event_size,)`. + :param bool trainable_loc: if True, the make the location trainable. + :param bool trainable_scale: if True, the make the scale trainable. + """ + super().__init__(event_shape=loc.shape, validate_args=False) self.log_2_pi = math.log(2 * math.pi) if trainable_loc: self.register_parameter('loc', nn.Parameter(loc)) @@ -44,11 +54,21 @@ def log_prob(self, value: torch.Tensor) -> torch.Tensor: class DenseGaussian(torch.distributions.Distribution, nn.Module): + """ + Dense Gaussian distribution. Extends torch.distributions.Distribution and torch.nn.Module. + """ def __init__(self, loc: torch.Tensor, cov: torch.Tensor, trainable_loc: bool = False): - super().__init__(event_shape=loc.shape) + """ + DenseGaussian constructor. + + :param torch.Tensor loc: location vector with shape `(event_size,)`. + :param torch.Tensor cov: covariance matrix with shape `(event_size, event_size)`. + :param bool trainable_loc: if True, the make the location trainable. + """ + super().__init__(event_shape=loc.shape, validate_args=False) event_size = int(torch.prod(torch.as_tensor(self.event_shape))) if cov.shape != (event_size, event_size): raise ValueError("Incorrect covariance matrix shape") diff --git a/torchflows/base_distributions/mixture.py b/torchflows/base_distributions/mixture.py index 3c35358..17f3a0f 100644 --- a/torchflows/base_distributions/mixture.py +++ b/torchflows/base_distributions/mixture.py @@ -8,12 +8,21 @@ class Mixture(torch.distributions.Distribution, nn.Module): + """ + Base mixture distribution class. Extends torch.distributions.Distribution and torch.nn.Module. + """ def __init__(self, components: List[torch.distributions.Distribution], weights: torch.Tensor = None): + """ + Mixture constructor. + + :param List[torch.distributions.Distribution] components: list of distribution components. + :param torch.Tensor weights: tensor of weights with shape `(n_components,)`. + """ if weights is None: weights = torch.ones(len(components)) / len(components) - super().__init__(event_shape=components[0].event_shape) + super().__init__(event_shape=components[0].event_shape, validate_args=False) self.register_buffer('log_weights', torch.log(weights)) self.components = components self.categorical = torch.distributions.Categorical(probs=weights) @@ -37,12 +46,25 @@ def log_prob(self, value: torch.Tensor) -> torch.Tensor: class DiagonalGaussianMixture(Mixture): + """ + Mixture distribution of diagonal Gaussians. Extends Mixture. + """ + def __init__(self, locs: torch.Tensor, scales: torch.Tensor, weights: torch.Tensor = None, trainable_locs: bool = False, trainable_scales: bool = False): + """ + DiagonalGaussianMixture constructor. + + :param torch.Tensor locs: tensor of locations with shape `(n_components, event_size)`. + :param torch.Tensor scales: tensor of scales with shape `(n_components, event_size)`. + :param torch.Tensor weights: tensor of weights with shape `(n_components,)`. + :param bool trainable_locs: if True, make locations trainable. + :param bool trainable_scales: if True, make scales trainable. + """ n_components, *event_shape = locs.shape components = [] for i in range(n_components): @@ -56,6 +78,14 @@ def __init__(self, covs: torch.Tensor, weights: torch.Tensor = None, trainable_locs: bool = False): + """ + DenseGaussianMixture constructor. Extends Mixture. + + :param torch.Tensor locs: tensor of locations with shape `(n_components, event_size)`. + :param torch.Tensor covs: tensor of covariance matrices with shape `(n_components, event_size, event_size)`. + :param torch.Tensor weights: tensor of weights with shape `(n_components,)`. + :param bool trainable_locs: if True, make locations trainable. + """ n_components, *event_shape = locs.shape components = [] for i in range(n_components): diff --git a/torchflows/bijections/__init__.py b/torchflows/bijections/__init__.py deleted file mode 100644 index 4a51679..0000000 --- a/torchflows/bijections/__init__.py +++ /dev/null @@ -1,16 +0,0 @@ -from torchflows.bijections.finite.autoregressive.architectures import * -from torchflows.bijections.finite.autoregressive.layers import * -from torchflows.bijections.continuous.ffjord import FFJORD -from torchflows.bijections.continuous.rnode import RNODE -from torchflows.bijections.continuous.otflow import OTFlow -from torchflows.bijections.continuous.ddnf import DeepDiffeomorphicBijection -from torchflows.bijections.finite.residual.planar import Planar, InversePlanar -from torchflows.bijections.finite.residual.quasi_autoregressive import QuasiAutoregressiveFlowBlock -from torchflows.bijections.finite.residual.radial import Radial -from torchflows.bijections.finite.residual.sylvester import IdentitySylvester, PermutationSylvester, \ - HouseholderSylvester, Sylvester -from torchflows.bijections.finite.residual.iterative import InvertibleResNetBlock, ResFlowBlock -from torchflows.bijections.finite.residual.architectures import InvertibleResNet, ResFlow, ProximalResFlow -from torchflows.bijections.finite.residual.proximal import ProximalResFlowBlock -from torchflows.bijections.finite.linear import LowerTriangular, Orthogonal, LU, QR -from torchflows.bijections.finite.linear import Identity \ No newline at end of file diff --git a/torchflows/bijections/base.py b/torchflows/bijections/base.py index c161084..23012fb 100644 --- a/torchflows/bijections/base.py +++ b/torchflows/bijections/base.py @@ -9,12 +9,17 @@ class Bijection(nn.Module): + """Bijection class. + """ def __init__(self, event_shape: Union[torch.Size, Tuple[int, ...]], context_shape: Union[torch.Size, Tuple[int, ...]] = None, **kwargs): - """ - Bijection class. + """Bijection constructor. + + :param event_shape: shape of the event tensor. + :param context_shape: shape of the context tensor. + :param kwargs: unused. """ super().__init__() self.event_shape = event_shape @@ -23,26 +28,26 @@ def __init__(self, self.transformed_shape = self.event_shape # Overwritten in multiscale flows TODO make into property def forward(self, x: torch.Tensor, context: torch.Tensor = None) -> Tuple[torch.Tensor, torch.Tensor]: - """ - Forward bijection map. + """Forward bijection map. Returns the output vector and the log Jacobian determinant of the forward transform. - :param x: input array with shape (*batch_shape, *event_shape). - :param context: context array with shape (*batch_shape, *context_shape). - :return: output array and log determinant. The output array has shape (*batch_shape, *event_shape); the log - determinant has shape (*batch_shape,). + :param torch.Tensor x: input array with shape `(*batch_shape, *event_shape)`. + :param torch.Tensor context: context array with shape `(*batch_shape, *context_shape)`. + :return: output array and log determinant. The output array has shape `(*batch_shape, *event_shape)`; the log + determinant has shape `(*batch_shape,)`. + :rtype: Tuple[torch.Tensor, torch.Tensor] """ raise NotImplementedError def inverse(self, z: torch.Tensor, context: torch.Tensor = None) -> Tuple[torch.Tensor, torch.Tensor]: - """ - Inverse bijection map. + """Inverse bijection map. Returns the output vector and the log Jacobian determinant of the inverse transform. - :param z: input array with shape (*batch_shape, *event_shape). - :param context: context array with shape (*batch_shape, *context_shape). - :return: output array and log determinant. The output array has shape (*batch_shape, *event_shape); the log - determinant has shape (*batch_shape,). + :param z: input array with shape `(*batch_shape, *event_shape)`. + :param context: context array with shape `(*batch_shape, *context_shape)`. + :return: output array and log determinant. The output array has shape `(*batch_shape, *event_shape)`; the log + determinant has shape `(*batch_shape,)`. + :rtype: Tuple[torch.Tensor, torch.Tensor] """ raise NotImplementedError @@ -85,25 +90,39 @@ def batch_inverse(self, x: torch.Tensor, batch_size: int, context: torch.Tensor def regularization(self): return 0.0 -def invert(bijection): - """ - Swap the forward and inverse methods of the input bijection. +def invert(bijection: Bijection) -> Bijection: + """Swap the forward and inverse methods of the input bijection. + + :param Bijection bijection: bijection to be inverted. + :returns: inverted bijection. + :rtype: Bijection """ bijection.forward, bijection.inverse = bijection.inverse, bijection.forward return bijection class BijectiveComposition(Bijection): + """ + Composition of bijections. Inherits from Bijection. + """ def __init__(self, event_shape: Union[torch.Size, Tuple[int, ...]], layers: List[Bijection], context_shape: Union[torch.Size, Tuple[int, ...]] = None, **kwargs): + """ + BijectiveComposition constructor. + + :param event_shape: shape of the event tensor. + :param List[Bijection] layers: bijection layers. + :param context_shape: shape of the context tensor. + :param kwargs: unused. + """ super().__init__(event_shape=event_shape, context_shape=context_shape) self.layers = nn.ModuleList(layers) def forward(self, x: torch.Tensor, context: torch.Tensor = None, **kwargs) -> Tuple[torch.Tensor, torch.Tensor]: - log_det = torch.zeros(size=get_batch_shape(x, event_shape=self.event_shape), device=x.device) + log_det = torch.zeros(size=get_batch_shape(x, event_shape=self.event_shape)).to(x) for layer in self.layers: x, log_det_layer = layer(x, context=context) log_det += log_det_layer @@ -111,7 +130,7 @@ def forward(self, x: torch.Tensor, context: torch.Tensor = None, **kwargs) -> Tu return z, log_det def inverse(self, z: torch.Tensor, context: torch.Tensor = None, **kwargs) -> Tuple[torch.Tensor, torch.Tensor]: - log_det = torch.zeros(size=get_batch_shape(z, event_shape=self.event_shape), device=z.device) + log_det = torch.zeros(size=get_batch_shape(z, event_shape=self.event_shape)).to(z) for layer in self.layers[::-1]: z, log_det_layer = layer.inverse(z, context=context) log_det += log_det_layer diff --git a/torchflows/bijections/continuous/__init__.py b/torchflows/bijections/continuous/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/torchflows/bijections/continuous/base.py b/torchflows/bijections/continuous/base.py index 6020366..365606e 100644 --- a/torchflows/bijections/continuous/base.py +++ b/torchflows/bijections/continuous/base.py @@ -265,6 +265,8 @@ def divergence_step(self, dy, y) -> torch.Tensor: class ContinuousBijection(Bijection): """ Base class for bijections of continuous normalizing flows. + + Reference: Chen et al. "Neural Ordinary Differential Equations" (2019); https://arxiv.org/abs/1806.07366. """ def __init__(self, event_shape: Union[torch.Size, Tuple[int, ...]], @@ -276,12 +278,16 @@ def __init__(self, rtol: float = 1e-5, **kwargs): """ + ContinuousBijection constructor. - :param event_shape: + :param event_shape: shape of the event tensor. :param f: function to be integrated. - :param end_time: integrate f from t=0 to t=time_upper_bound. Default: 1. + :param context_shape: shape of the context tensor. + :param end_time: integrate f from time 0 to this time. Default: 1. :param solver: which solver to use. - :param kwargs: + :param atol: absolute tolerance for numerical integration. + :param rtol: relative tolerance for numerical integration. + :param kwargs: unused. """ super().__init__(event_shape, context_shape) self.f = f @@ -299,11 +305,13 @@ def inverse(self, integration_times: torch.Tensor = None, **kwargs) -> Tuple[torch.Tensor, torch.Tensor]: """ + Inverse pass of the continuous bijection. - :param z: tensor with shape (*batch_shape, *event_shape). + :param z: tensor with shape `(*batch_shape, *event_shape)`. :param integration_times: - :param kwargs: - :return: + :param kwargs: keyword arguments passed to self.f.before_odeint in the torchdiffeq solver. + :return: transformed tensor and log determinant of the transformation. + :rtype: Tuple[torch.Tensor, torch.Tensor] """ # Import from torchdiffeq locally, so the package does not break if torchdiffeq not installed @@ -346,6 +354,16 @@ def forward(self, integration_times: torch.Tensor = None, noise: torch.Tensor = None, **kwargs) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Forward pass for the continuous bijection. + + :param torch.Tensor x: tensor with shape `(*batch_shape, *event_shape)`. + :param torch.Tensor integration_times: + :param torch.Tensor noise: + :param kwargs: keyword arguments to be passed to `self.inverse`. + :returns: transformed tensor and log determinant of the transformation. + :rtype: Tuple[torch.Tensor, torch.Tensor] + """ if integration_times is None: integration_times = self.make_integrations_times(x) return self.inverse( diff --git a/torchflows/bijections/continuous/ddnf.py b/torchflows/bijections/continuous/ddnf.py index fc03562..5f253e5 100644 --- a/torchflows/bijections/continuous/ddnf.py +++ b/torchflows/bijections/continuous/ddnf.py @@ -7,21 +7,21 @@ class DeepDiffeomorphicBijection(ApproximateContinuousBijection): - """ - Base bijection for the DDNF model. - Note that this model is implemented WITHOUT Geodesic regularization. - This is because torchdiffeq ODE solvers do not output the predicted velocity, only the point. - While the paper presents DDNF as a continuous normalizing flow, it is easier implement as a Residual normalizing - flow in this library. + """Deep diffeomorphic normalizing flow (DDNF) architecture. - IMPORTANT NOTE: the Euler solver prouduces very inaccurate results. Switching to the DOPRI5 solver massively - improves reconstruction quality. However, we leave the Euler solver as it is presented in the original method. + Notes: + - this model is implemented without Geodesic regularization. This is because torchdiffeq ODE solvers do not output the predicted velocity, only the point. + - while the paper presents DDNF as a continuous normalizing flow, it implemented as a residual normalizing flow in this library. There is no functional difference. + - IMPORTANT: the Euler solver produces very inaccurate results. Switching to the DOPRI5 solver massively improves reconstruction quality. However, we leave the Euler solver as it is presented in the original method. - Salman et al. Deep diffeomorphic normalizing flows (2018). + Reference: Salman et al. "Deep diffeomorphic normalizing flows" (2018); https://arxiv.org/abs/1810.03256. """ def __init__(self, event_shape: Union[torch.Size, Tuple[int, ...]], n_steps: int = 150, **kwargs): """ + Constructor. + + :param event_shape: shape of the event tensor. :param n_steps: parameter T in the paper, i.e. the number of ResNet cells. """ n_dim = int(torch.prod(torch.as_tensor(event_shape))) diff --git a/torchflows/bijections/continuous/ffjord.py b/torchflows/bijections/continuous/ffjord.py index ea63ccb..f5229ae 100644 --- a/torchflows/bijections/continuous/ffjord.py +++ b/torchflows/bijections/continuous/ffjord.py @@ -12,6 +12,10 @@ # https://github.com/rtqichen/ffjord/blob/master/lib/layers/cnf.py class FFJORD(ApproximateContinuousBijection): + """ Free-form Jacobian of reversible dynamics (FFJORD) architecture. + + Gratwohl et al. "FFJORD: Free-form Continuous Dynamics for Scalable Reversible Generative Models" (2018); https://arxiv.org/abs/1810.01367. + """ def __init__(self, event_shape: Union[torch.Size, Tuple[int, ...]], **kwargs): n_dim = int(torch.prod(torch.as_tensor(event_shape))) diff_eq = RegularizedApproximateODEFunction(create_nn(n_dim)) diff --git a/torchflows/bijections/continuous/otflow.py b/torchflows/bijections/continuous/otflow.py index ccf735c..8571458 100644 --- a/torchflows/bijections/continuous/otflow.py +++ b/torchflows/bijections/continuous/otflow.py @@ -202,6 +202,11 @@ def compute_log_det(self, t, x): class OTFlow(ExactContinuousBijection): + """ + Optimal transport flow (OT-flow) architecture. + + Reference: Onken et al. "OT-Flow: Fast and Accurate Continuous Normalizing Flows via Optimal Transport" (2021); https://arxiv.org/abs/2006.00104. + """ def __init__(self, event_shape: Union[torch.Size, Tuple[int, ...]], **kwargs): n_dim = int(torch.prod(torch.as_tensor(event_shape))) diff_eq = OTFlowODEFunction(n_dim) diff --git a/torchflows/bijections/continuous/rnode.py b/torchflows/bijections/continuous/rnode.py index d9b9692..66d5aa5 100644 --- a/torchflows/bijections/continuous/rnode.py +++ b/torchflows/bijections/continuous/rnode.py @@ -8,6 +8,10 @@ # https://github.com/cfinlay/ffjord-rnode/blob/master/train.py class RNODE(ApproximateContinuousBijection): + """Regularized neural ordinary differential equation (RNODE) architecture. + + Reference: Finlay et al. "How to train your neural ODE: the world of Jacobian and kinetic regularization" (2020); https://arxiv.org/abs/2002.02798. + """ def __init__(self, event_shape: Union[torch.Size, Tuple[int, ...]], **kwargs): n_dim = int(torch.prod(torch.as_tensor(event_shape))) diff_eq = RegularizedApproximateODEFunction(create_nn(n_dim), regularization="sq_jac_norm") diff --git a/torchflows/bijections/finite/__init__.py b/torchflows/bijections/finite/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/torchflows/bijections/finite/autoregressive/__init__.py b/torchflows/bijections/finite/autoregressive/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/torchflows/bijections/finite/autoregressive/architectures.py b/torchflows/bijections/finite/autoregressive/architectures.py index 2ab1941..3cc3ce9 100644 --- a/torchflows/bijections/finite/autoregressive/architectures.py +++ b/torchflows/bijections/finite/autoregressive/architectures.py @@ -39,6 +39,10 @@ def make_basic_layers(base_bijection: Type[ class NICE(BijectiveComposition): + """Nonlinear independent components estimation (NICE) architecture. + + Reference: Dinh et al. "NICE: Non-linear Independent Components Estimation" (2015); https://arxiv.org/abs/1410.8516. + """ def __init__(self, event_shape, n_layers: int = 2, @@ -51,6 +55,10 @@ def __init__(self, class RealNVP(BijectiveComposition): + """Real non-volume-preserving (Real NVP) architecture. + + Reference: Dinh et al. "Density estimation using Real NVP" (2017); https://arxiv.org/abs/1605.08803. + """ def __init__(self, event_shape, n_layers: int = 2, @@ -63,6 +71,10 @@ def __init__(self, class InverseRealNVP(BijectiveComposition): + """Inverse of the Real NVP architecture. + + Reference: Dinh et al. "Density estimation using Real NVP" (2017); https://arxiv.org/abs/1605.08803. + """ def __init__(self, event_shape, n_layers: int = 2, @@ -75,8 +87,9 @@ def __init__(self, class MAF(BijectiveComposition): - """ - Expressive bijection with slightly unstable inverse due to autoregressive formulation. + """Masked autoregressive flow (MAF) architecture. + + Reference: Papamakarios et al. "Masked Autoregressive Flow for Density Estimation" (2018); https://arxiv.org/abs/1705.07057. """ def __init__(self, event_shape, n_layers: int = 2, **kwargs): @@ -87,6 +100,11 @@ def __init__(self, event_shape, n_layers: int = 2, **kwargs): class IAF(BijectiveComposition): + """Inverse autoregressive flow (IAF) architecture. + + Reference: Kingma et al. "Improving Variational Inference with Inverse Autoregressive Flow" (2017); https://arxiv.org/abs/1606.04934. + """ + def __init__(self, event_shape, n_layers: int = 2, **kwargs): if isinstance(event_shape, int): event_shape = (event_shape,) @@ -95,6 +113,10 @@ def __init__(self, event_shape, n_layers: int = 2, **kwargs): class CouplingRQNSF(BijectiveComposition): + """Coupling rational quadratic neural spline flow (C-RQNSF) architecture. + + Reference: Durkan et al. "Neural Spline Flows" (2019); https://arxiv.org/abs/1906.04032. + """ def __init__(self, event_shape, n_layers: int = 2, @@ -107,8 +129,9 @@ def __init__(self, class MaskedAutoregressiveRQNSF(BijectiveComposition): - """ - Expressive bijection with unstable inverse due to autoregressive formulation. + """Masked autoregressive rational quadratic neural spline flow (MA-RQNSF) architecture. + + Reference: Durkan et al. "Neural Spline Flows" (2019); https://arxiv.org/abs/1906.04032. """ def __init__(self, event_shape, n_layers: int = 2, **kwargs): @@ -119,6 +142,10 @@ def __init__(self, event_shape, n_layers: int = 2, **kwargs): class CouplingLRS(BijectiveComposition): + """Coupling linear rational spline (C-LRS) architecture. + + Reference: Dolatabadi et al. "Invertible Generative Modeling using Linear Rational Splines" (2020); https://arxiv.org/abs/2001.05168. + """ def __init__(self, event_shape, n_layers: int = 2, @@ -131,6 +158,10 @@ def __init__(self, class MaskedAutoregressiveLRS(BijectiveComposition): + """Masked autoregressive linear rational spline (MA-LRS) architecture. + + Reference: Dolatabadi et al. "Invertible Generative Modeling using Linear Rational Splines" (2020); https://arxiv.org/abs/2001.05168. + """ def __init__(self, event_shape, n_layers: int = 2, **kwargs): if isinstance(event_shape, int): event_shape = (event_shape,) @@ -139,6 +170,10 @@ def __init__(self, event_shape, n_layers: int = 2, **kwargs): class InverseAutoregressiveRQNSF(BijectiveComposition): + """Inverse autoregressive rational quadratic neural spline flow (IA-RQNSF) architecture. + + Reference: Durkan et al. "Neural Spline Flows" (2019); https://arxiv.org/abs/1906.04032. + """ def __init__(self, event_shape, n_layers: int = 2, **kwargs): if isinstance(event_shape, int): event_shape = (event_shape,) @@ -147,6 +182,10 @@ def __init__(self, event_shape, n_layers: int = 2, **kwargs): class CouplingDSF(BijectiveComposition): + """Coupling deep sigmoidal flow (C-DSF) architecture. + + Reference: Huang et al. "Neural Autoregressive Flows" (2018); https://arxiv.org/abs/1804.00779. + """ def __init__(self, event_shape, n_layers: int = 2, @@ -159,6 +198,10 @@ def __init__(self, class UMNNMAF(BijectiveComposition): + """Unconstrained monotonic neural network masked autoregressive flow (UMNN-MAF) architecture. + + Reference: Wehenkel and Louppe "Unconstrained Monotonic Neural Networks" (2021); https://arxiv.org/abs/1908.05164. + """ def __init__(self, event_shape, n_layers: int = 1, **kwargs): if isinstance(event_shape, int): event_shape = (event_shape,) diff --git a/torchflows/bijections/finite/autoregressive/conditioning/__init__.py b/torchflows/bijections/finite/autoregressive/conditioning/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/torchflows/bijections/finite/autoregressive/conditioning/transforms.py b/torchflows/bijections/finite/autoregressive/conditioning/transforms.py index 2272449..61f4cc5 100644 --- a/torchflows/bijections/finite/autoregressive/conditioning/transforms.py +++ b/torchflows/bijections/finite/autoregressive/conditioning/transforms.py @@ -234,7 +234,7 @@ def __init__(self, self.sequential = nn.Sequential(*layers) def predict_theta_flat(self, x: torch.Tensor, context: torch.Tensor = None): - return self.sequential(self.context_combiner(x, context)) / 1000.0 + return self.sequential(self.context_combiner(x, context)) class Linear(FeedForward): @@ -257,7 +257,7 @@ def __init__(self, event_size: int, hidden_size: int, block_size: int, nonlinear self.sequential = nn.Sequential(*layers) def forward(self, x): - return x + self.sequential(x) / 1000.0 + return x + self.sequential(x) def __init__(self, input_event_shape: torch.Size, @@ -289,7 +289,7 @@ def __init__(self, self.sequential = nn.Sequential(*layers) def predict_theta_flat(self, x: torch.Tensor, context: torch.Tensor = None): - return self.sequential(self.context_combiner(x, context)) / 1000.0 + return self.sequential(self.context_combiner(x, context)) class CombinedConditioner(nn.Module): diff --git a/torchflows/bijections/finite/autoregressive/layers_base.py b/torchflows/bijections/finite/autoregressive/layers_base.py index 0817257..c75e0f6 100644 --- a/torchflows/bijections/finite/autoregressive/layers_base.py +++ b/torchflows/bijections/finite/autoregressive/layers_base.py @@ -180,7 +180,7 @@ def __init__(self, transformer: ScalarTransformer, fill_value: float = None): ) if fill_value is None: - self.value = nn.Parameter(torch.randn(*transformer.parameter_shape) / 1000.0) + self.value = nn.Parameter(torch.randn(*transformer.parameter_shape)) else: self.value = nn.Parameter(torch.full(size=transformer.parameter_shape, fill_value=fill_value)) diff --git a/torchflows/bijections/finite/autoregressive/transformers/__init__.py b/torchflows/bijections/finite/autoregressive/transformers/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/torchflows/bijections/finite/autoregressive/transformers/combination/__init__.py b/torchflows/bijections/finite/autoregressive/transformers/combination/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/torchflows/bijections/finite/autoregressive/transformers/integration/__init__.py b/torchflows/bijections/finite/autoregressive/transformers/integration/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/torchflows/bijections/finite/autoregressive/transformers/linear/__init__.py b/torchflows/bijections/finite/autoregressive/transformers/linear/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/torchflows/bijections/finite/autoregressive/transformers/linear/convolution.py b/torchflows/bijections/finite/autoregressive/transformers/linear/convolution.py index 6b088c0..741327a 100644 --- a/torchflows/bijections/finite/autoregressive/transformers/linear/convolution.py +++ b/torchflows/bijections/finite/autoregressive/transformers/linear/convolution.py @@ -1,7 +1,5 @@ from typing import Union, Tuple import torch - -from torchflows.bijections import LU from torchflows.bijections.finite.autoregressive.transformers.base import TensorTransformer from torchflows.bijections.finite.autoregressive.transformers.linear.matrix import LUTransformer from torchflows.utils import sum_except_batch, get_batch_shape diff --git a/torchflows/bijections/finite/autoregressive/transformers/spline/__init__.py b/torchflows/bijections/finite/autoregressive/transformers/spline/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/torchflows/bijections/finite/multiscale/__init__.py b/torchflows/bijections/finite/multiscale/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/torchflows/bijections/finite/multiscale/architectures.py b/torchflows/bijections/finite/multiscale/architectures.py index 17b69de..2a6dea4 100644 --- a/torchflows/bijections/finite/multiscale/architectures.py +++ b/torchflows/bijections/finite/multiscale/architectures.py @@ -1,5 +1,6 @@ import torch +from torchflows.bijections.base import BijectiveComposition from torchflows.bijections.finite.autoregressive.layers import ElementwiseAffine from torchflows.bijections.finite.autoregressive.transformers.linear.affine import Affine, Shift from torchflows.bijections.finite.autoregressive.transformers.spline.rational_quadratic import RationalQuadratic @@ -9,7 +10,6 @@ DeepDenseSigmoid, DenseSigmoid ) -from torchflows.bijections import BijectiveComposition from torchflows.bijections.finite.multiscale.base import MultiscaleBijection, FactoredBijection @@ -141,6 +141,10 @@ def make_image_layers(*args, factored: bool = False, **kwargs): class MultiscaleRealNVP(BijectiveComposition): + """Multiscale version of Real NVP. + + Reference: Dinh et al. "Density estimation using Real NVP" (2017); https://arxiv.org/abs/1605.08803. + """ def __init__(self, event_shape, n_layers: int = None, @@ -155,6 +159,12 @@ def __init__(self, class MultiscaleNICE(BijectiveComposition): + """Multiscale version of NICE. + + References: + - Dinh et al. "NICE: Non-linear Independent Components Estimation" (2015); https://arxiv.org/abs/1410.8516. + - Dinh et al. "Density estimation using Real NVP" (2017); https://arxiv.org/abs/1605.08803. + """ def __init__(self, event_shape, n_layers: int = None, @@ -169,6 +179,12 @@ def __init__(self, class MultiscaleRQNSF(BijectiveComposition): + """Multiscale version of C-RQNSF. + + References: + - Durkan et al. "Neural Spline Flows" (2019); https://arxiv.org/abs/1906.04032. + - Dinh et al. "Density estimation using Real NVP" (2017); https://arxiv.org/abs/1605.08803. + """ def __init__(self, event_shape, n_layers: int = None, @@ -184,6 +200,12 @@ def __init__(self, class MultiscaleLRSNSF(BijectiveComposition): + """Multiscale version of C-LRS. + + References: + - Dolatabadi et al. "Invertible Generative Modeling using Linear Rational Splines" (2020); https://arxiv.org/abs/2001.05168. + - Dinh et al. "Density estimation using Real NVP" (2017); https://arxiv.org/abs/1605.08803. + """ def __init__(self, event_shape, n_layers: int = None, diff --git a/torchflows/bijections/finite/multiscale/base.py b/torchflows/bijections/finite/multiscale/base.py index 8f53109..365c5d6 100644 --- a/torchflows/bijections/finite/multiscale/base.py +++ b/torchflows/bijections/finite/multiscale/base.py @@ -2,9 +2,8 @@ import torch -from torchflows.bijections import BijectiveComposition from torchflows.bijections.finite.autoregressive.conditioning.transforms import ConditionerTransform -from torchflows.bijections.base import Bijection +from torchflows.bijections.base import Bijection, BijectiveComposition from torchflows.bijections.finite.autoregressive.layers_base import CouplingBijection from torchflows.bijections.finite.autoregressive.transformers.base import TensorTransformer from torchflows.bijections.finite.multiscale.coupling import make_image_coupling, Checkerboard, \ @@ -257,6 +256,9 @@ def inverse(self, z: torch.Tensor, context: torch.Tensor = None) -> Tuple[torch. class MultiscaleBijection(BijectiveComposition): + """ + Multiscale bijection class. Used for efficient image modeling. Inherits from BijectiveComposition. + """ def __init__(self, input_event_shape, transformer_class: Type[TensorTransformer], @@ -265,6 +267,17 @@ def __init__(self, use_squeeze_layer: bool = True, use_resnet: bool = False, **kwargs): + """ + MultiscaleBijection constructor. + + :param input_event_shape: shape of event tensor. + :param TensorTransformer transformer_class: type of transformer. + :param int n_checkerboard_layers: number of checkerboard coupling layers. + :param int n_channel_wise_layers: number of channel wise coupling layers. + :param bool use_squeeze_layer: if True, use a squeeze layer. + :param bool use_resnet: if True, use ResNet as the conditioner network. + :param kwargs: keyword arguments for BijectiveComposition superclass constructor. + """ checkerboard_layers = [ CheckerboardCoupling( input_event_shape, diff --git a/torchflows/bijections/finite/residual/__init__.py b/torchflows/bijections/finite/residual/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/torchflows/bijections/finite/residual/architectures.py b/torchflows/bijections/finite/residual/architectures.py index 2c91fbf..d44194d 100644 --- a/torchflows/bijections/finite/residual/architectures.py +++ b/torchflows/bijections/finite/residual/architectures.py @@ -2,8 +2,8 @@ import torch -from torchflows.bijections import Affine from torchflows.bijections.base import BijectiveComposition +from torchflows.bijections.finite.autoregressive.transformers.linear.affine import Affine from torchflows.bijections.finite.residual.base import ResidualComposition from torchflows.bijections.finite.residual.iterative import InvertibleResNetBlock, ResFlowBlock from torchflows.bijections.finite.residual.proximal import ProximalResFlowBlock @@ -13,6 +13,10 @@ class InvertibleResNet(ResidualComposition): + """Invertible residual network (i-ResNet) architecture. + + Reference: Behrmann et al. "Invertible Residual Networks" (2019); https://arxiv.org/abs/1811.00995. + """ def __init__(self, event_shape, context_shape=None, n_layers: int = 16, **kwargs): blocks = [ InvertibleResNetBlock(event_shape=event_shape, context_shape=context_shape, **kwargs) @@ -22,6 +26,10 @@ def __init__(self, event_shape, context_shape=None, n_layers: int = 16, **kwargs class ResFlow(ResidualComposition): + """Residual flow (ResFlow) architecture. + + Reference: Chen et al. "Residual Flows for Invertible Generative Modeling" (2020); https://arxiv.org/abs/1906.02735. + """ def __init__(self, event_shape, context_shape=None, n_layers: int = 16, **kwargs): blocks = [ ResFlowBlock(event_shape=event_shape, context_shape=context_shape, **kwargs) @@ -31,6 +39,10 @@ def __init__(self, event_shape, context_shape=None, n_layers: int = 16, **kwargs class ProximalResFlow(ResidualComposition): + """Proximal residual flow architecture. + + Reference: Hertrich "Proximal Residual Flows for Bayesian Inverse Problems" (2022); https://arxiv.org/abs/2211.17158. + """ def __init__(self, event_shape, context_shape=None, n_layers: int = 16, **kwargs): blocks = [ ProximalResFlowBlock(event_shape=event_shape, context_shape=context_shape, gamma=0.01, **kwargs) @@ -40,6 +52,12 @@ def __init__(self, event_shape, context_shape=None, n_layers: int = 16, **kwargs class PlanarFlow(BijectiveComposition): + """Planar flow architecture. + + Note: this model currently supports only one-way transformations. + + Reference: Rezende and Mohamed "Variational Inference with Normalizing Flows" (2016); https://arxiv.org/abs/1505.05770. + """ def __init__(self, event_shape: Union[torch.Size, Tuple[int, ...]], n_layers: int = 2): if n_layers < 1: raise ValueError(f"Flow needs at least one layer, but got {n_layers}") @@ -51,6 +69,12 @@ def __init__(self, event_shape: Union[torch.Size, Tuple[int, ...]], n_layers: in class RadialFlow(BijectiveComposition): + """Radial flow architecture. + + Note: this model currently supports only one-way transformations. + + Reference: Rezende and Mohamed "Variational Inference with Normalizing Flows" (2016); https://arxiv.org/abs/1505.05770. + """ def __init__(self, event_shape: Union[torch.Size, Tuple[int, ...]], n_layers: int = 2): if n_layers < 1: raise ValueError(f"Flow needs at least one layer, but got {n_layers}") @@ -62,6 +86,12 @@ def __init__(self, event_shape: Union[torch.Size, Tuple[int, ...]], n_layers: in class SylvesterFlow(BijectiveComposition): + """Sylvester flow architecture. + + Note: this model currently supports only one-way transformations. + + Reference: Van den Berg et al. "Sylvester Normalizing Flows for Variational Inference" (2019); https://arxiv.org/abs/1803.05649. + """ def __init__(self, event_shape: Union[torch.Size, Tuple[int, ...]], n_layers: int = 2, **kwargs): if n_layers < 1: raise ValueError(f"Flow needs at least one layer, but got {n_layers}") diff --git a/torchflows/flows.py b/torchflows/flows.py index 15a5499..8cc8362 100644 --- a/torchflows/flows.py +++ b/torchflows/flows.py @@ -7,34 +7,41 @@ from tqdm import tqdm from torchflows.bijections.base import Bijection from torchflows.utils import flatten_event, unflatten_event, create_data_loader +from torchflows.base_distributions.gaussian import DiagonalGaussian class BaseFlow(nn.Module): + """Base normalizing flow class. + """ + def __init__(self, event_shape, base_distribution: Union[torch.distributions.Distribution, str] = 'standard_normal'): + """BaseFlow constructor. + + :param event_shape: shape of the event space. + :param base_distribution: base distribution. + """ super().__init__() self.event_shape = event_shape self.event_size = int(torch.prod(torch.as_tensor(event_shape))) if base_distribution == 'standard_normal': - self.base = torch.distributions.MultivariateNormal( - loc=torch.zeros(self.event_size), - covariance_matrix=torch.eye(self.event_size) - ) + self.base = DiagonalGaussian(loc=torch.zeros(self.event_size), scale=torch.ones(self.event_size)) elif isinstance(base_distribution, torch.distributions.Distribution): self.base = base_distribution else: raise ValueError(f'Invalid base distribution: {base_distribution}') - self.device_buffer = torch.empty(size=()) + self.register_buffer('device_buffer', torch.empty(size=())) def get_device(self): + """Returns the torch device for this object. + """ return self.device_buffer.device def base_log_prob(self, z: torch.Tensor): - """ - Compute the log probability of input z under the base distribution. + """Compute the log probability of input z under the base distribution. :param z: input tensor. :return: log probability of the input tensor. @@ -44,8 +51,7 @@ def base_log_prob(self, z: torch.Tensor): return log_prob def base_sample(self, sample_shape: Union[torch.Size, Tuple[int, ...]]): - """ - Sample from the base distribution. + """Sample from the base distribution. :param sample_shape: desired shape of sampled tensor. :return: tensor with shape sample_shape. @@ -55,6 +61,8 @@ def base_sample(self, sample_shape: Union[torch.Size, Tuple[int, ...]]): return z def regularization(self): + """Compute the regularization term used in training. + """ return 0.0 def fit(self, @@ -72,24 +80,23 @@ def fit(self, keep_best_weights: bool = True, early_stopping: bool = False, early_stopping_threshold: int = 50): - """ - Fit the normalizing flow. + """Fit the normalizing flow to a dataset. Fitting the flow means finding the parameters of the bijection that maximize the probability of training data. Bijection parameters are iteratively updated for a specified number of epochs. If context data is provided, the normalizing flow learns the distribution of data conditional on context data. - :param x_train: training data with shape (n_training_data, *event_shape). + :param x_train: training data with shape `(n_training_data, *event_shape)`. :param n_epochs: perform fitting for this many steps. :param lr: learning rate. In general, lower learning rates are recommended for high-parametric bijections. :param batch_size: in each epoch, split training data into batches of this size and perform a parameter update for each batch. :param shuffle: shuffle training data. This helps avoid incorrect fitting if nearby training samples are similar. :param show_progress: show a progress bar with the current batch loss. - :param w_train: training data weights with shape (n_training_data,). - :param context_train: training data context tensor with shape (n_training_data, *context_shape). - :param x_val: validation data with shape (n_validation_data, *event_shape). - :param w_val: validation data weights with shape (n_validation_data,). - :param context_val: validation data context tensor with shape (n_validation_data, *context_shape). + :param w_train: training data weights with shape `(n_training_data,)`. + :param context_train: training data context tensor with shape `(n_training_data, *context_shape)`. + :param x_val: validation data with shape `(n_validation_data, *event_shape)`. + :param w_val: validation data weights with shape `(n_validation_data,)`. + :param context_val: validation data context tensor with shape `(n_validation_data, *context_shape)`. :param keep_best_weights: if True and validation data is provided, keep the bijection weights with the highest probability of validation data. :param early_stopping: if True and validation data is provided, stop the training procedure early once validation loss stops improving for a specified number of consecutive epochs. :param early_stopping_threshold: if early_stopping is True, fitting stops after no improvement in validation loss for this many epochs. @@ -246,18 +253,14 @@ def variational_fit(self, early_stopping_threshold: int = 50, keep_best_weights: bool = True, show_progress: bool = False): - """ - Train a distribution with stochastic variational inference. - Stochastic variational inference lets us train a distribution using the unnormalized target log density - instead of a fixed dataset. + """Train the normalizing flow to fit a target log probability. - Refer to Rezende, Mohamed: "Variational Inference with Normalizing Flows" (2015) for more details - (https://arxiv.org/abs/1505.05770, loss definition in Equation 15, training pseudocode for conditional flows in - Algorithm 1). + Stochastic variational inference lets us train a distribution using the unnormalized target log density instead of a fixed dataset. + Refer to Rezende, Mohamed: "Variational Inference with Normalizing Flows" (2015) for more details (https://arxiv.org/abs/1505.05770, loss definition in Equation 15, training pseudocode for conditional flows in Algorithm 1). :param callable target_log_prob: function that computes the unnormalized target log density for a batch of - points. Receives input batch with shape = (*batch_shape, *event_shape) and outputs batch with - shape = (*batch_shape). + points. Receives input batch with shape `(*batch_shape, *event_shape)` and outputs batch with + shape `(*batch_shape)`. :param int n_epochs: number of training epochs. :param float lr: learning rate for the AdamW optimizer. :param float n_samples: number of samples to estimate the variational loss in each training step. @@ -300,29 +303,29 @@ def variational_fit(self, class Flow(BaseFlow): - """ - Normalizing flow class. + """Normalizing flow class. Inherits from BaseFlow. This class represents a bijective transformation of a standard Gaussian distribution (the base distribution). A normalizing flow is itself a distribution which we can sample from or use it to compute the density of inputs. """ def __init__(self, bijection: Bijection, **kwargs): - """ + """Flow constructor. - :param bijection: transformation component of the normalizing flow. + :param Bijection bijection: transformation component of the normalizing flow. + :param kwargs: keyword arguments passed to BaseFlow. """ super().__init__(event_shape=bijection.event_shape, **kwargs) self.register_module('bijection', bijection) def forward_with_log_prob(self, x: torch.Tensor, context: torch.Tensor = None): - """ - Transform the input x to the space of the base distribution. + """Transform the input x to the space of the base distribution. - :param x: input tensor. - :param context: context tensor upon which the transformation is conditioned. + :param torch.Tensor x: input tensor. + :param torch.Tensor context: context tensor upon which the transformation is conditioned. :return: transformed tensor and the logarithm of the absolute value of the Jacobian determinant of the transformation. + :rtype: Tuple[torch.Tensor, torch.Tensor] """ if context is not None: assert context.shape[0] == x.shape[0] @@ -331,13 +334,13 @@ def forward_with_log_prob(self, x: torch.Tensor, context: torch.Tensor = None): log_base = self.base_log_prob(z) return z, log_base + log_det - def log_prob(self, x: torch.Tensor, context: torch.Tensor = None): - """ - Compute the logarithm of the probability density of input x according to the normalizing flow. + def log_prob(self, x: torch.Tensor, context: torch.Tensor = None) -> torch.Tensor: + """Compute the logarithm of the probability density of input x according to the normalizing flow. - :param x: input tensor. - :param context: context tensor. - :return: + :param torch.Tensor x: input tensor. + :param torch.Tensor context: context tensor. + :return: tensor of log probabilities. + :rtype: torch.Tensor. """ return self.forward_with_log_prob(x, context)[1] @@ -345,17 +348,18 @@ def sample(self, sample_shape: Union[int, torch.Size, Tuple[int, ...]], context: torch.Tensor = None, no_grad: bool = False, - return_log_prob: bool = False): - """ - Sample from the normalizing flow. + return_log_prob: bool = False) -> Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]: + """Sample from the normalizing flow. If context given, sample n tensors for each context tensor. Otherwise, sample n tensors. :param sample_shape: shape of tensors to sample. - :param context: context tensor with shape c. - :param no_grad: if True, do not track gradients in the inverse pass. - :return: samples with shape (n, *event_shape) if no context given or (n, *c, *event_shape) if context given. + :param torch.Tensor context: context tensor with shape `c`. + :param bool no_grad: if True, do not track gradients in the inverse pass. + :param return_log_prob: if True, return log probabilities of sampled points as the second tuple component. + :return: samples with shape `(*sample_shape, *event_shape)` if no context given or `(*sample_shape, *c, *event_shape)` if context given. + :rtype: torch.Tensor """ if isinstance(sample_shape, int): sample_shape = (sample_shape,) @@ -364,7 +368,7 @@ def sample(self, sample_shape = (*sample_shape, len(context)) z = self.base_sample(sample_shape=sample_shape) context = context[None].repeat( - *[sample_shape, *([1] * len(context.shape))]) # Make context shape match z shape + *[*sample_shape, *([1] * len(context.shape))]) # Make context shape match z shape assert z.shape[:2] == context.shape[:2] else: z = self.base_sample(sample_shape=sample_shape) @@ -392,7 +396,20 @@ def regularization(self): class FlowMixture(BaseFlow): + """Base class for mixtures of normalizing flows. Inherits from BaseFlow. + + A mixture uses flow objects as components, as well as their associated categorical distribution weights. + It is a typical statistical mixture. + """ + def __init__(self, flows: List[Flow], weights: List[float] = None, trainable_weights: bool = False): + """FlowMixture constructor. + + :param List[Flow] flows: normalizing flow components. + :param List[float] weights: mixture weights corresponding to flow components. All weights must be greater than 0. The sum of + the weights must equal 1. + :param bool trainable_weights: if True, makes the weights trainable. + """ super().__init__(event_shape=flows[0].event_shape) # Use uniform weights by default @@ -409,7 +426,14 @@ def __init__(self, flows: List[Flow], weights: List[float] = None, trainable_wei else: self.logit_weights = torch.log(torch.tensor(weights)) - def log_prob(self, x: torch.Tensor, context: torch.Tensor = None): + def log_prob(self, x: torch.Tensor, context: torch.Tensor = None) -> torch.Tensor: + """Compute the log probability density of inputs x. + + :param torch.Tensor x: input tensor. + :param torch.Tensor context: context tensor. + :return: tensor of log probabilities. + :rtype: torch.Tensor + """ flow_log_probs = torch.stack([flow.log_prob(x, context=context) for flow in self.flows]) # (n_flows, *batch_shape) @@ -418,7 +442,20 @@ def log_prob(self, x: torch.Tensor, context: torch.Tensor = None): log_prob = torch.logsumexp(log_weights_reshaped + flow_log_probs, dim=0) # batch_shape return log_prob - def sample(self, n: int, context: torch.Tensor = None, no_grad: bool = False, return_log_prob: bool = False): + def sample(self, + n: int, + context: torch.Tensor = None, + no_grad: bool = False, + return_log_prob: bool = False) -> torch.Tensor: + """Sample from the flow mixture. + + :param int n: number of samples to draw. + :param torch.Tensor context: context tensor. + :param bool no_grad: if True, do not track gradients in the inverse pass during sampling. + :param return_log_prob: if True, return log probabilities of sampled points as the second tuple component. + :returns: tensor of drawn samples. + :rtype: torch.Tensor + """ flow_samples = [] flow_log_probs = [] for flow in self.flows: diff --git a/torchflows/neural_networks/__init__.py b/torchflows/neural_networks/__init__.py deleted file mode 100644 index e69de29..0000000