From cd01d8b38a8064d28d299c55cc8876572e9634c8 Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Tue, 13 Aug 2024 16:53:36 +0200 Subject: [PATCH 01/39] Update docs --- docs/requirements.txt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/docs/requirements.txt b/docs/requirements.txt index 1d628f2..266f693 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -1,2 +1,3 @@ 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.0 \ No newline at end of file From f91f14f5f980e2b49d36136a2d71a95d0ef88764 Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Tue, 13 Aug 2024 16:59:30 +0200 Subject: [PATCH 02/39] Update docs --- docs/{ => source}/conf.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename docs/{ => source}/conf.py (100%) diff --git a/docs/conf.py b/docs/source/conf.py similarity index 100% rename from docs/conf.py rename to docs/source/conf.py From 8fa97efebe2d83fde11c12ae4e59e959e8efc61e Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Tue, 13 Aug 2024 17:07:33 +0200 Subject: [PATCH 03/39] Update rtd --- .readthedocs.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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: From 98fc157b7e201805785b6d4234ab58d8267d8711 Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Tue, 13 Aug 2024 18:05:43 +0200 Subject: [PATCH 04/39] Add example notebook --- .../notebooks/training_with_datasets.ipynb | 106 ++++++++++++++++++ 1 file changed, 106 insertions(+) create mode 100644 docs/source/notebooks/training_with_datasets.ipynb diff --git a/docs/source/notebooks/training_with_datasets.ipynb b/docs/source/notebooks/training_with_datasets.ipynb new file mode 100644 index 0000000..438cb80 --- /dev/null +++ b/docs/source/notebooks/training_with_datasets.ipynb @@ -0,0 +1,106 @@ +{ + "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:03:55.165346Z", + "start_time": "2024-08-13T16:03:45.176180Z" + } + }, + "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, 62.07it/s, Training loss (batch): 3.0298]\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:04:45.588546Z", + "start_time": "2024-08-13T16:04:16.213016Z" + } + }, + "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: 14%|█▎ | 1360/10000 [00:29<03:06, 46.32it/s, Training loss (batch): 3.0288, Validation loss: 3.0304 [best: 3.0295 @ 1309]]\n" + ] + } + ], + "execution_count": 3 + } + ], + "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 +} From 5be8350cd3f03d4773d2285c99f4acdd51937883 Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Tue, 13 Aug 2024 19:23:33 +0200 Subject: [PATCH 05/39] Remove identity initialization --- .../finite/autoregressive/conditioning/transforms.py | 6 +++--- torchflows/bijections/finite/autoregressive/layers_base.py | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) 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)) From 6bd009963cd18add97bf237043b61f94ba57a59a Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Tue, 13 Aug 2024 19:23:42 +0200 Subject: [PATCH 06/39] Add documentation --- torchflows/flows.py | 23 ++++++++++++++++++++--- 1 file changed, 20 insertions(+), 3 deletions(-) diff --git a/torchflows/flows.py b/torchflows/flows.py index 15a5499..23355d3 100644 --- a/torchflows/flows.py +++ b/torchflows/flows.py @@ -10,9 +10,19 @@ 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))) @@ -30,6 +40,9 @@ def __init__(self, self.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): @@ -55,6 +68,9 @@ 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, @@ -73,7 +89,7 @@ def fit(self, 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. @@ -247,10 +263,10 @@ def variational_fit(self, keep_best_weights: bool = True, show_progress: bool = False): """ - Train a distribution with stochastic variational inference. + Train the normalizing flow to fit a target log probability. + 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). @@ -311,6 +327,7 @@ def __init__(self, bijection: Bijection, **kwargs): """ :param 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) From 90d90a61decd180042cdd9e63e01c7483407b9dc Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Tue, 13 Aug 2024 19:31:20 +0200 Subject: [PATCH 07/39] Update index.rst --- docs/source/index.rst | 23 +++++++++++++++++++---- 1 file changed, 19 insertions(+), 4 deletions(-) diff --git a/docs/source/index.rst b/docs/source/index.rst index 25d73c9..7263743 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -7,12 +7,27 @@ 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. +Installing and usage +---------- -.. note:: +Install Torchflows with pip: - This project is under active development. +.. code-block:: console + + pip install torchflows + +Create a flow and train it as follows: +.. code-block:: python + + import torch + from torchflows.flows import Flow + from torchflows.architectures import RealNVP + + x = torch.randn((1000, 25)) # generate synthetic 25-dimensional data + flow = Flow(RealNVP((25,))) + flow.fit(x, show_progress=True) + + x_new = flow.sample((150,)) # sample 150 new points from the flow Contents -------- From 614816b7567da4b1b9b1975dc8338f8b5e15c9e2 Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Tue, 13 Aug 2024 19:31:50 +0200 Subject: [PATCH 08/39] Add notebooks --- .../computing_log_determinants.ipynb | 90 ++++++++++ docs/source/notebooks/image_modeling.ipynb | 133 ++++++++++++++ .../notebooks/modifying_architectures.ipynb | 95 ++++++++++ .../notebooks/training_with_datasets.ipynb | 61 ++++++- .../training_with_variational_inference.ipynb | 162 ++++++++++++++++++ 5 files changed, 534 insertions(+), 7 deletions(-) create mode 100644 docs/source/notebooks/computing_log_determinants.ipynb create mode 100644 docs/source/notebooks/image_modeling.ipynb create mode 100644 docs/source/notebooks/modifying_architectures.ipynb create mode 100644 docs/source/notebooks/training_with_variational_inference.ipynb diff --git a/docs/source/notebooks/computing_log_determinants.ipynb b/docs/source/notebooks/computing_log_determinants.ipynb new file mode 100644 index 0000000..117ff46 --- /dev/null +++ b/docs/source/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/source/notebooks/image_modeling.ipynb b/docs/source/notebooks/image_modeling.ipynb new file mode 100644 index 0000000..cc1db94 --- /dev/null +++ b/docs/source/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/source/notebooks/modifying_architectures.ipynb b/docs/source/notebooks/modifying_architectures.ipynb new file mode 100644 index 0000000..57e8888 --- /dev/null +++ b/docs/source/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/source/notebooks/training_with_datasets.ipynb b/docs/source/notebooks/training_with_datasets.ipynb index 438cb80..b6ea860 100644 --- a/docs/source/notebooks/training_with_datasets.ipynb +++ b/docs/source/notebooks/training_with_datasets.ipynb @@ -19,8 +19,8 @@ "metadata": { "collapsed": true, "ExecuteTime": { - "end_time": "2024-08-13T16:03:55.165346Z", - "start_time": "2024-08-13T16:03:45.176180Z" + "end_time": "2024-08-13T16:17:28.856450Z", + "start_time": "2024-08-13T16:17:18.459461Z" } }, "source": [ @@ -39,7 +39,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Fitting NF: 100%|██████████| 500/500 [00:08<00:00, 62.07it/s, Training loss (batch): 3.0298]\n" + "Fitting NF: 100%|██████████| 500/500 [00:08<00:00, 59.25it/s, Training loss (batch): 3.0914]\n" ] } ], @@ -58,8 +58,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2024-08-13T16:04:45.588546Z", - "start_time": "2024-08-13T16:04:16.213016Z" + "end_time": "2024-08-13T16:18:44.066344Z", + "start_time": "2024-08-13T16:17:28.865435Z" } }, "cell_type": "code", @@ -75,11 +75,58 @@ "name": "stderr", "output_type": "stream", "text": [ - "Fitting NF: 14%|█▎ | 1360/10000 [00:29<03:06, 46.32it/s, Training loss (batch): 3.0288, Validation loss: 3.0304 [best: 3.0295 @ 1309]]\n" + "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": 3 + "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": { diff --git a/docs/source/notebooks/training_with_variational_inference.ipynb b/docs/source/notebooks/training_with_variational_inference.ipynb new file mode 100644 index 0000000..134cec7 --- /dev/null +++ b/docs/source/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 +} From 3a61063cb8c002166caf622976e0ab80064973a6 Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Tue, 13 Aug 2024 19:42:42 +0200 Subject: [PATCH 09/39] Modify sphinx files --- docs/modules.rst | 7 ++ .../computing_log_determinants.ipynb | 0 .../notebooks/image_modeling.ipynb | 0 .../notebooks/modifying_architectures.ipynb | 0 .../notebooks/training_with_datasets.ipynb | 0 .../training_with_variational_inference.ipynb | 0 docs/source/api.rst | 7 -- docs/source/conf.py | 37 ++++---- docs/source/index.rst | 49 ++++------- docs/source/usage.rst | 13 --- docs/torchflows.base_distributions.rst | 29 +++++++ docs/torchflows.bijections.continuous.rst | 61 +++++++++++++ ...ons.finite.autoregressive.conditioning.rst | 37 ++++++++ ...flows.bijections.finite.autoregressive.rst | 62 ++++++++++++++ ...utoregressive.transformers.combination.rst | 37 ++++++++ ...utoregressive.transformers.integration.rst | 29 +++++++ ...ite.autoregressive.transformers.linear.rst | 37 ++++++++ ...ons.finite.autoregressive.transformers.rst | 32 +++++++ ...ite.autoregressive.transformers.spline.rst | 61 +++++++++++++ ...orchflows.bijections.finite.multiscale.rst | 45 ++++++++++ .../torchflows.bijections.finite.residual.rst | 85 +++++++++++++++++++ docs/torchflows.bijections.finite.rst | 31 +++++++ docs/torchflows.bijections.rst | 46 ++++++++++ docs/torchflows.neural_networks.rst | 29 +++++++ docs/torchflows.rst | 55 ++++++++++++ 25 files changed, 716 insertions(+), 73 deletions(-) create mode 100644 docs/modules.rst rename docs/{source => }/notebooks/computing_log_determinants.ipynb (100%) rename docs/{source => }/notebooks/image_modeling.ipynb (100%) rename docs/{source => }/notebooks/modifying_architectures.ipynb (100%) rename docs/{source => }/notebooks/training_with_datasets.ipynb (100%) rename docs/{source => }/notebooks/training_with_variational_inference.ipynb (100%) delete mode 100644 docs/source/api.rst delete mode 100644 docs/source/usage.rst create mode 100644 docs/torchflows.base_distributions.rst create mode 100644 docs/torchflows.bijections.continuous.rst create mode 100644 docs/torchflows.bijections.finite.autoregressive.conditioning.rst create mode 100644 docs/torchflows.bijections.finite.autoregressive.rst create mode 100644 docs/torchflows.bijections.finite.autoregressive.transformers.combination.rst create mode 100644 docs/torchflows.bijections.finite.autoregressive.transformers.integration.rst create mode 100644 docs/torchflows.bijections.finite.autoregressive.transformers.linear.rst create mode 100644 docs/torchflows.bijections.finite.autoregressive.transformers.rst create mode 100644 docs/torchflows.bijections.finite.autoregressive.transformers.spline.rst create mode 100644 docs/torchflows.bijections.finite.multiscale.rst create mode 100644 docs/torchflows.bijections.finite.residual.rst create mode 100644 docs/torchflows.bijections.finite.rst create mode 100644 docs/torchflows.bijections.rst create mode 100644 docs/torchflows.neural_networks.rst create mode 100644 docs/torchflows.rst diff --git a/docs/modules.rst b/docs/modules.rst new file mode 100644 index 0000000..0291e09 --- /dev/null +++ b/docs/modules.rst @@ -0,0 +1,7 @@ +torchflows +========== + +.. toctree:: + :maxdepth: 4 + + torchflows diff --git a/docs/source/notebooks/computing_log_determinants.ipynb b/docs/notebooks/computing_log_determinants.ipynb similarity index 100% rename from docs/source/notebooks/computing_log_determinants.ipynb rename to docs/notebooks/computing_log_determinants.ipynb diff --git a/docs/source/notebooks/image_modeling.ipynb b/docs/notebooks/image_modeling.ipynb similarity index 100% rename from docs/source/notebooks/image_modeling.ipynb rename to docs/notebooks/image_modeling.ipynb diff --git a/docs/source/notebooks/modifying_architectures.ipynb b/docs/notebooks/modifying_architectures.ipynb similarity index 100% rename from docs/source/notebooks/modifying_architectures.ipynb rename to docs/notebooks/modifying_architectures.ipynb diff --git a/docs/source/notebooks/training_with_datasets.ipynb b/docs/notebooks/training_with_datasets.ipynb similarity index 100% rename from docs/source/notebooks/training_with_datasets.ipynb rename to docs/notebooks/training_with_datasets.ipynb diff --git a/docs/source/notebooks/training_with_variational_inference.ipynb b/docs/notebooks/training_with_variational_inference.ipynb similarity index 100% rename from docs/source/notebooks/training_with_variational_inference.ipynb rename to docs/notebooks/training_with_variational_inference.ipynb 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/conf.py b/docs/source/conf.py index 97e096a..610294d 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -1,35 +1,28 @@ # 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 +# -- Project information ----------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information -project = 'torchflows' +project = 'Torchflows' copyright = '2024, David Nabergoj' author = 'David Nabergoj' +release = '1.0.2' -release = '1.0' -version = '1.0.2' +# -- General configuration --------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration -# -- General configuration +extensions = [] -extensions = [ - 'sphinx.ext.duration', - 'sphinx.ext.doctest', - 'sphinx.ext.autodoc', - 'sphinx.ext.autosummary', - 'sphinx.ext.intersphinx', -] +templates_path = ['_templates'] +exclude_patterns = [] -intersphinx_mapping = { - 'python': ('https://docs.python.org/3/', None), - 'sphinx': ('https://www.sphinx-doc.org/en/master/', None), -} -intersphinx_disabled_domains = ['std'] -templates_path = ['_templates'] -# -- Options for HTML output +# -- Options for HTML output ------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output html_theme = 'sphinx_rtd_theme' - -# -- Options for EPUB output -epub_show_urls = 'footnote' +html_static_path = ['_static'] diff --git a/docs/source/index.rst b/docs/source/index.rst index 7263743..b6ac59f 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -1,38 +1,25 @@ -Welcome to Torchflows documentation! -=================================== +.. Torchflows documentation master file, created by + sphinx-quickstart on Tue Aug 13 19:37:48 2024. + You can adapt this file completely to your liking, but it should at least + contain the root `toctree` directive. -Torchflows is a library for generative modeling and density estimation using normalizing flows. -It implements many normalizing flow architectures and their building blocks for: +Torchflows documentation +======================== -* easy use of normalizing flows as trainable distributions; -* easy implementation of new normalizing flows. +Add your content using ``reStructuredText`` syntax. See the +`reStructuredText `_ +documentation for details. -Installing and usage ----------- -Install Torchflows with pip: - -.. code-block:: console - - pip install torchflows - -Create a flow and train it as follows: -.. code-block:: python - - import torch - from torchflows.flows import Flow - from torchflows.architectures import RealNVP - - x = torch.randn((1000, 25)) # generate synthetic 25-dimensional data - flow = Flow(RealNVP((25,))) - flow.fit(x, show_progress=True) - - x_new = flow.sample((150,)) # sample 150 new points from the flow +.. toctree:: + :maxdepth: 2 + :caption: Contents: -Contents --------- + modules -.. toctree:: +Indices and tables +=================== - usage - api \ No newline at end of file +* :ref: `genindex` +* :ref: `modindex` +* :ref: `search` \ 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/docs/torchflows.base_distributions.rst b/docs/torchflows.base_distributions.rst new file mode 100644 index 0000000..92580e9 --- /dev/null +++ b/docs/torchflows.base_distributions.rst @@ -0,0 +1,29 @@ +torchflows.base\_distributions package +====================================== + +Submodules +---------- + +torchflows.base\_distributions.gaussian module +---------------------------------------------- + +.. automodule:: torchflows.base_distributions.gaussian + :members: + :undoc-members: + :show-inheritance: + +torchflows.base\_distributions.mixture module +--------------------------------------------- + +.. automodule:: torchflows.base_distributions.mixture + :members: + :undoc-members: + :show-inheritance: + +Module contents +--------------- + +.. automodule:: torchflows.base_distributions + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/torchflows.bijections.continuous.rst b/docs/torchflows.bijections.continuous.rst new file mode 100644 index 0000000..21f04f6 --- /dev/null +++ b/docs/torchflows.bijections.continuous.rst @@ -0,0 +1,61 @@ +torchflows.bijections.continuous package +======================================== + +Submodules +---------- + +torchflows.bijections.continuous.base module +-------------------------------------------- + +.. automodule:: torchflows.bijections.continuous.base + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.continuous.ddnf module +-------------------------------------------- + +.. automodule:: torchflows.bijections.continuous.ddnf + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.continuous.ffjord module +---------------------------------------------- + +.. automodule:: torchflows.bijections.continuous.ffjord + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.continuous.layers module +---------------------------------------------- + +.. automodule:: torchflows.bijections.continuous.layers + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.continuous.otflow module +---------------------------------------------- + +.. automodule:: torchflows.bijections.continuous.otflow + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.continuous.rnode module +--------------------------------------------- + +.. automodule:: torchflows.bijections.continuous.rnode + :members: + :undoc-members: + :show-inheritance: + +Module contents +--------------- + +.. automodule:: torchflows.bijections.continuous + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/torchflows.bijections.finite.autoregressive.conditioning.rst b/docs/torchflows.bijections.finite.autoregressive.conditioning.rst new file mode 100644 index 0000000..a12cb8b --- /dev/null +++ b/docs/torchflows.bijections.finite.autoregressive.conditioning.rst @@ -0,0 +1,37 @@ +torchflows.bijections.finite.autoregressive.conditioning package +================================================================ + +Submodules +---------- + +torchflows.bijections.finite.autoregressive.conditioning.context module +----------------------------------------------------------------------- + +.. automodule:: torchflows.bijections.finite.autoregressive.conditioning.context + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.finite.autoregressive.conditioning.coupling\_masks module +------------------------------------------------------------------------------- + +.. automodule:: torchflows.bijections.finite.autoregressive.conditioning.coupling_masks + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.finite.autoregressive.conditioning.transforms module +-------------------------------------------------------------------------- + +.. automodule:: torchflows.bijections.finite.autoregressive.conditioning.transforms + :members: + :undoc-members: + :show-inheritance: + +Module contents +--------------- + +.. automodule:: torchflows.bijections.finite.autoregressive.conditioning + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/torchflows.bijections.finite.autoregressive.rst b/docs/torchflows.bijections.finite.autoregressive.rst new file mode 100644 index 0000000..6e399f6 --- /dev/null +++ b/docs/torchflows.bijections.finite.autoregressive.rst @@ -0,0 +1,62 @@ +torchflows.bijections.finite.autoregressive package +=================================================== + +Subpackages +----------- + +.. toctree:: + :maxdepth: 4 + + torchflows.bijections.finite.autoregressive.conditioning + torchflows.bijections.finite.autoregressive.transformers + +Submodules +---------- + +torchflows.bijections.finite.autoregressive.architectures module +---------------------------------------------------------------- + +.. automodule:: torchflows.bijections.finite.autoregressive.architectures + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.finite.autoregressive.conditioner\_transforms module +-------------------------------------------------------------------------- + +.. automodule:: torchflows.bijections.finite.autoregressive.conditioner_transforms + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.finite.autoregressive.layers module +--------------------------------------------------------- + +.. automodule:: torchflows.bijections.finite.autoregressive.layers + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.finite.autoregressive.layers\_base module +--------------------------------------------------------------- + +.. automodule:: torchflows.bijections.finite.autoregressive.layers_base + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.finite.autoregressive.util module +------------------------------------------------------- + +.. automodule:: torchflows.bijections.finite.autoregressive.util + :members: + :undoc-members: + :show-inheritance: + +Module contents +--------------- + +.. automodule:: torchflows.bijections.finite.autoregressive + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/torchflows.bijections.finite.autoregressive.transformers.combination.rst b/docs/torchflows.bijections.finite.autoregressive.transformers.combination.rst new file mode 100644 index 0000000..9bca584 --- /dev/null +++ b/docs/torchflows.bijections.finite.autoregressive.transformers.combination.rst @@ -0,0 +1,37 @@ +torchflows.bijections.finite.autoregressive.transformers.combination package +============================================================================ + +Submodules +---------- + +torchflows.bijections.finite.autoregressive.transformers.combination.base module +-------------------------------------------------------------------------------- + +.. automodule:: torchflows.bijections.finite.autoregressive.transformers.combination.base + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.finite.autoregressive.transformers.combination.sigmoid module +----------------------------------------------------------------------------------- + +.. automodule:: torchflows.bijections.finite.autoregressive.transformers.combination.sigmoid + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.finite.autoregressive.transformers.combination.sigmoid\_util module +----------------------------------------------------------------------------------------- + +.. automodule:: torchflows.bijections.finite.autoregressive.transformers.combination.sigmoid_util + :members: + :undoc-members: + :show-inheritance: + +Module contents +--------------- + +.. automodule:: torchflows.bijections.finite.autoregressive.transformers.combination + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/torchflows.bijections.finite.autoregressive.transformers.integration.rst b/docs/torchflows.bijections.finite.autoregressive.transformers.integration.rst new file mode 100644 index 0000000..a4e33cb --- /dev/null +++ b/docs/torchflows.bijections.finite.autoregressive.transformers.integration.rst @@ -0,0 +1,29 @@ +torchflows.bijections.finite.autoregressive.transformers.integration package +============================================================================ + +Submodules +---------- + +torchflows.bijections.finite.autoregressive.transformers.integration.base module +-------------------------------------------------------------------------------- + +.. automodule:: torchflows.bijections.finite.autoregressive.transformers.integration.base + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.finite.autoregressive.transformers.integration.unconstrained\_monotonic\_neural\_network module +--------------------------------------------------------------------------------------------------------------------- + +.. automodule:: torchflows.bijections.finite.autoregressive.transformers.integration.unconstrained_monotonic_neural_network + :members: + :undoc-members: + :show-inheritance: + +Module contents +--------------- + +.. automodule:: torchflows.bijections.finite.autoregressive.transformers.integration + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/torchflows.bijections.finite.autoregressive.transformers.linear.rst b/docs/torchflows.bijections.finite.autoregressive.transformers.linear.rst new file mode 100644 index 0000000..bae30ce --- /dev/null +++ b/docs/torchflows.bijections.finite.autoregressive.transformers.linear.rst @@ -0,0 +1,37 @@ +torchflows.bijections.finite.autoregressive.transformers.linear package +======================================================================= + +Submodules +---------- + +torchflows.bijections.finite.autoregressive.transformers.linear.affine module +----------------------------------------------------------------------------- + +.. automodule:: torchflows.bijections.finite.autoregressive.transformers.linear.affine + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.finite.autoregressive.transformers.linear.convolution module +---------------------------------------------------------------------------------- + +.. automodule:: torchflows.bijections.finite.autoregressive.transformers.linear.convolution + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.finite.autoregressive.transformers.linear.matrix module +----------------------------------------------------------------------------- + +.. automodule:: torchflows.bijections.finite.autoregressive.transformers.linear.matrix + :members: + :undoc-members: + :show-inheritance: + +Module contents +--------------- + +.. automodule:: torchflows.bijections.finite.autoregressive.transformers.linear + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/torchflows.bijections.finite.autoregressive.transformers.rst b/docs/torchflows.bijections.finite.autoregressive.transformers.rst new file mode 100644 index 0000000..8649231 --- /dev/null +++ b/docs/torchflows.bijections.finite.autoregressive.transformers.rst @@ -0,0 +1,32 @@ +torchflows.bijections.finite.autoregressive.transformers package +================================================================ + +Subpackages +----------- + +.. toctree:: + :maxdepth: 4 + + torchflows.bijections.finite.autoregressive.transformers.combination + torchflows.bijections.finite.autoregressive.transformers.integration + torchflows.bijections.finite.autoregressive.transformers.linear + torchflows.bijections.finite.autoregressive.transformers.spline + +Submodules +---------- + +torchflows.bijections.finite.autoregressive.transformers.base module +-------------------------------------------------------------------- + +.. automodule:: torchflows.bijections.finite.autoregressive.transformers.base + :members: + :undoc-members: + :show-inheritance: + +Module contents +--------------- + +.. automodule:: torchflows.bijections.finite.autoregressive.transformers + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/torchflows.bijections.finite.autoregressive.transformers.spline.rst b/docs/torchflows.bijections.finite.autoregressive.transformers.spline.rst new file mode 100644 index 0000000..fbb80d0 --- /dev/null +++ b/docs/torchflows.bijections.finite.autoregressive.transformers.spline.rst @@ -0,0 +1,61 @@ +torchflows.bijections.finite.autoregressive.transformers.spline package +======================================================================= + +Submodules +---------- + +torchflows.bijections.finite.autoregressive.transformers.spline.base module +--------------------------------------------------------------------------- + +.. automodule:: torchflows.bijections.finite.autoregressive.transformers.spline.base + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.finite.autoregressive.transformers.spline.basis module +---------------------------------------------------------------------------- + +.. automodule:: torchflows.bijections.finite.autoregressive.transformers.spline.basis + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.finite.autoregressive.transformers.spline.cubic module +---------------------------------------------------------------------------- + +.. automodule:: torchflows.bijections.finite.autoregressive.transformers.spline.cubic + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.finite.autoregressive.transformers.spline.linear module +----------------------------------------------------------------------------- + +.. automodule:: torchflows.bijections.finite.autoregressive.transformers.spline.linear + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.finite.autoregressive.transformers.spline.linear\_rational module +--------------------------------------------------------------------------------------- + +.. automodule:: torchflows.bijections.finite.autoregressive.transformers.spline.linear_rational + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.finite.autoregressive.transformers.spline.rational\_quadratic module +------------------------------------------------------------------------------------------ + +.. automodule:: torchflows.bijections.finite.autoregressive.transformers.spline.rational_quadratic + :members: + :undoc-members: + :show-inheritance: + +Module contents +--------------- + +.. automodule:: torchflows.bijections.finite.autoregressive.transformers.spline + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/torchflows.bijections.finite.multiscale.rst b/docs/torchflows.bijections.finite.multiscale.rst new file mode 100644 index 0000000..3e15029 --- /dev/null +++ b/docs/torchflows.bijections.finite.multiscale.rst @@ -0,0 +1,45 @@ +torchflows.bijections.finite.multiscale package +=============================================== + +Submodules +---------- + +torchflows.bijections.finite.multiscale.architectures module +------------------------------------------------------------ + +.. automodule:: torchflows.bijections.finite.multiscale.architectures + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.finite.multiscale.base module +--------------------------------------------------- + +.. automodule:: torchflows.bijections.finite.multiscale.base + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.finite.multiscale.coupling module +------------------------------------------------------- + +.. automodule:: torchflows.bijections.finite.multiscale.coupling + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.finite.multiscale.layers module +----------------------------------------------------- + +.. automodule:: torchflows.bijections.finite.multiscale.layers + :members: + :undoc-members: + :show-inheritance: + +Module contents +--------------- + +.. automodule:: torchflows.bijections.finite.multiscale + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/torchflows.bijections.finite.residual.rst b/docs/torchflows.bijections.finite.residual.rst new file mode 100644 index 0000000..1a50566 --- /dev/null +++ b/docs/torchflows.bijections.finite.residual.rst @@ -0,0 +1,85 @@ +torchflows.bijections.finite.residual package +============================================= + +Submodules +---------- + +torchflows.bijections.finite.residual.architectures module +---------------------------------------------------------- + +.. automodule:: torchflows.bijections.finite.residual.architectures + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.finite.residual.base module +------------------------------------------------- + +.. automodule:: torchflows.bijections.finite.residual.base + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.finite.residual.iterative module +------------------------------------------------------ + +.. automodule:: torchflows.bijections.finite.residual.iterative + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.finite.residual.log\_abs\_det\_estimators module +---------------------------------------------------------------------- + +.. automodule:: torchflows.bijections.finite.residual.log_abs_det_estimators + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.finite.residual.planar module +--------------------------------------------------- + +.. automodule:: torchflows.bijections.finite.residual.planar + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.finite.residual.proximal module +----------------------------------------------------- + +.. automodule:: torchflows.bijections.finite.residual.proximal + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.finite.residual.quasi\_autoregressive module +------------------------------------------------------------------ + +.. automodule:: torchflows.bijections.finite.residual.quasi_autoregressive + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.finite.residual.radial module +--------------------------------------------------- + +.. automodule:: torchflows.bijections.finite.residual.radial + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.finite.residual.sylvester module +------------------------------------------------------ + +.. automodule:: torchflows.bijections.finite.residual.sylvester + :members: + :undoc-members: + :show-inheritance: + +Module contents +--------------- + +.. automodule:: torchflows.bijections.finite.residual + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/torchflows.bijections.finite.rst b/docs/torchflows.bijections.finite.rst new file mode 100644 index 0000000..4fb9565 --- /dev/null +++ b/docs/torchflows.bijections.finite.rst @@ -0,0 +1,31 @@ +torchflows.bijections.finite package +==================================== + +Subpackages +----------- + +.. toctree:: + :maxdepth: 4 + + torchflows.bijections.finite.autoregressive + torchflows.bijections.finite.multiscale + torchflows.bijections.finite.residual + +Submodules +---------- + +torchflows.bijections.finite.linear module +------------------------------------------ + +.. automodule:: torchflows.bijections.finite.linear + :members: + :undoc-members: + :show-inheritance: + +Module contents +--------------- + +.. automodule:: torchflows.bijections.finite + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/torchflows.bijections.rst b/docs/torchflows.bijections.rst new file mode 100644 index 0000000..7aab849 --- /dev/null +++ b/docs/torchflows.bijections.rst @@ -0,0 +1,46 @@ +torchflows.bijections package +============================= + +Subpackages +----------- + +.. toctree:: + :maxdepth: 4 + + torchflows.bijections.continuous + torchflows.bijections.finite + +Submodules +---------- + +torchflows.bijections.base module +--------------------------------- + +.. automodule:: torchflows.bijections.base + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.matrices module +------------------------------------- + +.. automodule:: torchflows.bijections.matrices + :members: + :undoc-members: + :show-inheritance: + +torchflows.bijections.numerical\_inversion module +------------------------------------------------- + +.. automodule:: torchflows.bijections.numerical_inversion + :members: + :undoc-members: + :show-inheritance: + +Module contents +--------------- + +.. automodule:: torchflows.bijections + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/torchflows.neural_networks.rst b/docs/torchflows.neural_networks.rst new file mode 100644 index 0000000..ab45ab7 --- /dev/null +++ b/docs/torchflows.neural_networks.rst @@ -0,0 +1,29 @@ +torchflows.neural\_networks package +=================================== + +Submodules +---------- + +torchflows.neural\_networks.convnet module +------------------------------------------ + +.. automodule:: torchflows.neural_networks.convnet + :members: + :undoc-members: + :show-inheritance: + +torchflows.neural\_networks.resnet module +----------------------------------------- + +.. automodule:: torchflows.neural_networks.resnet + :members: + :undoc-members: + :show-inheritance: + +Module contents +--------------- + +.. automodule:: torchflows.neural_networks + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/torchflows.rst b/docs/torchflows.rst new file mode 100644 index 0000000..c5b972c --- /dev/null +++ b/docs/torchflows.rst @@ -0,0 +1,55 @@ +torchflows package +================== + +Subpackages +----------- + +.. toctree:: + :maxdepth: 4 + + torchflows.base_distributions + torchflows.bijections + torchflows.neural_networks + +Submodules +---------- + +torchflows.architectures module +------------------------------- + +.. automodule:: torchflows.architectures + :members: + :undoc-members: + :show-inheritance: + +torchflows.flows module +----------------------- + +.. automodule:: torchflows.flows + :members: + :undoc-members: + :show-inheritance: + +torchflows.regularization module +-------------------------------- + +.. automodule:: torchflows.regularization + :members: + :undoc-members: + :show-inheritance: + +torchflows.utils module +----------------------- + +.. automodule:: torchflows.utils + :members: + :undoc-members: + :show-inheritance: + +Module contents +--------------- + +.. automodule:: torchflows + :members: + :undoc-members: + :show-inheritance: From 3c2349c97be6f1af2fb79ff3f487118c9be3c714 Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Tue, 13 Aug 2024 20:49:18 +0200 Subject: [PATCH 10/39] Remove __init__.py files in subdirectories, change imports accordingly --- test/test_autograd_bijections.py | 11 ++-- test/test_cuda.py | 2 +- test/test_fit.py | 7 ++- test/test_reconstruction_bijections.py | 15 ++--- test/test_sample.py | 2 +- test/test_sigmoid_transformer.py | 3 +- torchflows/__init__.py | 55 +++++++++++++------ torchflows/bijections/__init__.py | 16 ------ .../finite/autoregressive/__init__.py | 0 .../autoregressive/conditioning/__init__.py | 0 .../autoregressive/transformers/__init__.py | 0 .../transformers/combination/__init__.py | 0 .../transformers/integration/__init__.py | 0 .../transformers/linear/__init__.py | 0 .../transformers/linear/convolution.py | 2 - .../transformers/spline/__init__.py | 0 .../bijections/finite/multiscale/__init__.py | 0 .../finite/multiscale/architectures.py | 2 +- .../bijections/finite/multiscale/base.py | 3 +- .../bijections/finite/residual/__init__.py | 0 .../finite/residual/architectures.py | 2 +- torchflows/neural_networks/__init__.py | 0 22 files changed, 65 insertions(+), 55 deletions(-) delete mode 100644 torchflows/bijections/__init__.py delete mode 100644 torchflows/bijections/finite/autoregressive/__init__.py delete mode 100644 torchflows/bijections/finite/autoregressive/conditioning/__init__.py delete mode 100644 torchflows/bijections/finite/autoregressive/transformers/__init__.py delete mode 100644 torchflows/bijections/finite/autoregressive/transformers/combination/__init__.py delete mode 100644 torchflows/bijections/finite/autoregressive/transformers/integration/__init__.py delete mode 100644 torchflows/bijections/finite/autoregressive/transformers/linear/__init__.py delete mode 100644 torchflows/bijections/finite/autoregressive/transformers/spline/__init__.py delete mode 100644 torchflows/bijections/finite/multiscale/__init__.py delete mode 100644 torchflows/bijections/finite/residual/__init__.py delete mode 100644 torchflows/neural_networks/__init__.py 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..e449291 100644 --- a/test/test_cuda.py +++ b/test/test_cuda.py @@ -1,7 +1,7 @@ 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") 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/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/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/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/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..2b84260 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 diff --git a/torchflows/bijections/finite/multiscale/base.py b/torchflows/bijections/finite/multiscale/base.py index 8f53109..1b75259 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, \ 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..7795a17 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 diff --git a/torchflows/neural_networks/__init__.py b/torchflows/neural_networks/__init__.py deleted file mode 100644 index e69de29..0000000 From 01e7ef59fab19308ee301672e4a5192f96c3e2d8 Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Tue, 13 Aug 2024 20:57:28 +0200 Subject: [PATCH 11/39] Remove __init__.py files in subdirectories --- torchflows/base_distributions/__init__.py | 0 torchflows/bijections/continuous/__init__.py | 0 torchflows/bijections/finite/__init__.py | 0 3 files changed, 0 insertions(+), 0 deletions(-) delete mode 100644 torchflows/base_distributions/__init__.py delete mode 100644 torchflows/bijections/continuous/__init__.py delete mode 100644 torchflows/bijections/finite/__init__.py 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/bijections/continuous/__init__.py b/torchflows/bijections/continuous/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/torchflows/bijections/finite/__init__.py b/torchflows/bijections/finite/__init__.py deleted file mode 100644 index e69de29..0000000 From 318615398d49ac27f306f0c7aadd87f0fd074429 Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Wed, 14 Aug 2024 08:42:44 +0200 Subject: [PATCH 12/39] Update dcs --- docs/Makefile | 2 +- docs/make.bat | 8 +- docs/modules.rst | 7 -- docs/requirements.txt | 3 - docs/source/architectures.rst | 27 ++++++ docs/source/conf.py | 15 +++- docs/source/flow.rst | 9 ++ docs/source/index.rst | 20 ++--- docs/source/multiscale_architectures.rst | 9 ++ docs/source/usage.rst | 13 +++ docs/torchflows.base_distributions.rst | 29 ------- docs/torchflows.bijections.continuous.rst | 61 ------------- ...ons.finite.autoregressive.conditioning.rst | 37 -------- ...flows.bijections.finite.autoregressive.rst | 62 -------------- ...utoregressive.transformers.combination.rst | 37 -------- ...utoregressive.transformers.integration.rst | 29 ------- ...ite.autoregressive.transformers.linear.rst | 37 -------- ...ons.finite.autoregressive.transformers.rst | 32 ------- ...ite.autoregressive.transformers.spline.rst | 61 ------------- ...orchflows.bijections.finite.multiscale.rst | 45 ---------- .../torchflows.bijections.finite.residual.rst | 85 ------------------- docs/torchflows.bijections.finite.rst | 31 ------- docs/torchflows.bijections.rst | 46 ---------- docs/torchflows.neural_networks.rst | 29 ------- docs/torchflows.rst | 55 ------------ 25 files changed, 81 insertions(+), 708 deletions(-) delete mode 100644 docs/modules.rst delete mode 100644 docs/requirements.txt create mode 100644 docs/source/architectures.rst create mode 100644 docs/source/flow.rst create mode 100644 docs/source/multiscale_architectures.rst create mode 100644 docs/source/usage.rst delete mode 100644 docs/torchflows.base_distributions.rst delete mode 100644 docs/torchflows.bijections.continuous.rst delete mode 100644 docs/torchflows.bijections.finite.autoregressive.conditioning.rst delete mode 100644 docs/torchflows.bijections.finite.autoregressive.rst delete mode 100644 docs/torchflows.bijections.finite.autoregressive.transformers.combination.rst delete mode 100644 docs/torchflows.bijections.finite.autoregressive.transformers.integration.rst delete mode 100644 docs/torchflows.bijections.finite.autoregressive.transformers.linear.rst delete mode 100644 docs/torchflows.bijections.finite.autoregressive.transformers.rst delete mode 100644 docs/torchflows.bijections.finite.autoregressive.transformers.spline.rst delete mode 100644 docs/torchflows.bijections.finite.multiscale.rst delete mode 100644 docs/torchflows.bijections.finite.residual.rst delete mode 100644 docs/torchflows.bijections.finite.rst delete mode 100644 docs/torchflows.bijections.rst delete mode 100644 docs/torchflows.neural_networks.rst delete mode 100644 docs/torchflows.rst 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/modules.rst b/docs/modules.rst deleted file mode 100644 index 0291e09..0000000 --- a/docs/modules.rst +++ /dev/null @@ -1,7 +0,0 @@ -torchflows -========== - -.. toctree:: - :maxdepth: 4 - - torchflows diff --git a/docs/requirements.txt b/docs/requirements.txt deleted file mode 100644 index 266f693..0000000 --- a/docs/requirements.txt +++ /dev/null @@ -1,3 +0,0 @@ -sphinx==7.1.2 -sphinx-rtd-theme==1.3.0rc1 -torchflows>=1.0.0 \ No newline at end of file diff --git a/docs/source/architectures.rst b/docs/source/architectures.rst new file mode 100644 index 0000000..945fd04 --- /dev/null +++ b/docs/source/architectures.rst @@ -0,0 +1,27 @@ +Flow architectures +============================ + +.. _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 +.. autoclass:: torchflows.architectures.DeepDiffeomorphicBijection +.. autoclass:: torchflows.architectures.RNODE +.. autoclass:: torchflows.architectures.FFJORD +.. autoclass:: torchflows.architectures.OTFlow +.. autoclass:: torchflows.architectures.ResFlow +.. autoclass:: torchflows.architectures.ProximalResFlow +.. autoclass:: torchflows.architectures.InvertibleResNet +.. autoclass:: torchflows.architectures.Planar +.. autoclass:: torchflows.architectures.Radial +.. autoclass:: torchflows.architectures.Sylvester \ No newline at end of file diff --git a/docs/source/conf.py b/docs/source/conf.py index 610294d..cc5474f 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -5,6 +5,10 @@ # -- 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' @@ -14,15 +18,20 @@ # -- General configuration --------------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration -extensions = [] +extensions = [ + 'sphinx.ext.duration', + 'sphinx.ext.doctest', + 'sphinx.ext.autodoc', + 'sphinx.ext.autosummary', +] templates_path = ['_templates'] 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' html_static_path = ['_static'] + +epub_show_urls = 'footnote' diff --git a/docs/source/flow.rst b/docs/source/flow.rst new file mode 100644 index 0000000..5830f6a --- /dev/null +++ b/docs/source/flow.rst @@ -0,0 +1,9 @@ +Creating a Flow object +=============================== +The `Flow` object contains a base distribution and a bijection. + +.. _flow: + +.. autoclass:: torchflows.flows.Flow + +.. autoclass:: torchflows.flows.FlowMixture \ No newline at end of file diff --git a/docs/source/index.rst b/docs/source/index.rst index b6ac59f..d4cc6d3 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -1,25 +1,17 @@ .. Torchflows documentation master file, created by - sphinx-quickstart on Tue Aug 13 19:37:48 2024. + 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 ======================== -Add your content using ``reStructuredText`` syntax. See the -`reStructuredText `_ -documentation for details. - +Check out the :doc:`usage` section for more information, including how to :ref:`install ` Torchflows. .. toctree:: - :maxdepth: 2 - :caption: Contents: - - modules -Indices and tables -=================== + usage + flow + architectures + multiscale_architectures -* :ref: `genindex` -* :ref: `modindex` -* :ref: `search` \ No newline at end of file diff --git a/docs/source/multiscale_architectures.rst b/docs/source/multiscale_architectures.rst new file mode 100644 index 0000000..c0aef0d --- /dev/null +++ b/docs/source/multiscale_architectures.rst @@ -0,0 +1,9 @@ +Multiscale flow architectures +============================ + +.. _multiscale_architectures: + +.. autoclass:: torchflows.architectures.MultiscaleRealNVP +.. autoclass:: torchflows.architectures.MultiscaleRQNSF +.. autoclass:: torchflows.architectures.MultiscaleLRSNSF +.. autoclass:: torchflows.architectures.MultiscaleNICE \ No newline at end of file diff --git a/docs/source/usage.rst b/docs/source/usage.rst new file mode 100644 index 0000000..26c7ab9 --- /dev/null +++ b/docs/source/usage.rst @@ -0,0 +1,13 @@ +Usage +============== + +.. _installation: + +Installation +---------------------- + +Install Torchflows using pip: + +.. code-block:: console + + pip install torchflows diff --git a/docs/torchflows.base_distributions.rst b/docs/torchflows.base_distributions.rst deleted file mode 100644 index 92580e9..0000000 --- a/docs/torchflows.base_distributions.rst +++ /dev/null @@ -1,29 +0,0 @@ -torchflows.base\_distributions package -====================================== - -Submodules ----------- - -torchflows.base\_distributions.gaussian module ----------------------------------------------- - -.. automodule:: torchflows.base_distributions.gaussian - :members: - :undoc-members: - :show-inheritance: - -torchflows.base\_distributions.mixture module ---------------------------------------------- - -.. automodule:: torchflows.base_distributions.mixture - :members: - :undoc-members: - :show-inheritance: - -Module contents ---------------- - -.. automodule:: torchflows.base_distributions - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/torchflows.bijections.continuous.rst b/docs/torchflows.bijections.continuous.rst deleted file mode 100644 index 21f04f6..0000000 --- a/docs/torchflows.bijections.continuous.rst +++ /dev/null @@ -1,61 +0,0 @@ -torchflows.bijections.continuous package -======================================== - -Submodules ----------- - -torchflows.bijections.continuous.base module --------------------------------------------- - -.. automodule:: torchflows.bijections.continuous.base - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.continuous.ddnf module --------------------------------------------- - -.. automodule:: torchflows.bijections.continuous.ddnf - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.continuous.ffjord module ----------------------------------------------- - -.. automodule:: torchflows.bijections.continuous.ffjord - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.continuous.layers module ----------------------------------------------- - -.. automodule:: torchflows.bijections.continuous.layers - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.continuous.otflow module ----------------------------------------------- - -.. automodule:: torchflows.bijections.continuous.otflow - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.continuous.rnode module ---------------------------------------------- - -.. automodule:: torchflows.bijections.continuous.rnode - :members: - :undoc-members: - :show-inheritance: - -Module contents ---------------- - -.. automodule:: torchflows.bijections.continuous - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/torchflows.bijections.finite.autoregressive.conditioning.rst b/docs/torchflows.bijections.finite.autoregressive.conditioning.rst deleted file mode 100644 index a12cb8b..0000000 --- a/docs/torchflows.bijections.finite.autoregressive.conditioning.rst +++ /dev/null @@ -1,37 +0,0 @@ -torchflows.bijections.finite.autoregressive.conditioning package -================================================================ - -Submodules ----------- - -torchflows.bijections.finite.autoregressive.conditioning.context module ------------------------------------------------------------------------ - -.. automodule:: torchflows.bijections.finite.autoregressive.conditioning.context - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.finite.autoregressive.conditioning.coupling\_masks module -------------------------------------------------------------------------------- - -.. automodule:: torchflows.bijections.finite.autoregressive.conditioning.coupling_masks - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.finite.autoregressive.conditioning.transforms module --------------------------------------------------------------------------- - -.. automodule:: torchflows.bijections.finite.autoregressive.conditioning.transforms - :members: - :undoc-members: - :show-inheritance: - -Module contents ---------------- - -.. automodule:: torchflows.bijections.finite.autoregressive.conditioning - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/torchflows.bijections.finite.autoregressive.rst b/docs/torchflows.bijections.finite.autoregressive.rst deleted file mode 100644 index 6e399f6..0000000 --- a/docs/torchflows.bijections.finite.autoregressive.rst +++ /dev/null @@ -1,62 +0,0 @@ -torchflows.bijections.finite.autoregressive package -=================================================== - -Subpackages ------------ - -.. toctree:: - :maxdepth: 4 - - torchflows.bijections.finite.autoregressive.conditioning - torchflows.bijections.finite.autoregressive.transformers - -Submodules ----------- - -torchflows.bijections.finite.autoregressive.architectures module ----------------------------------------------------------------- - -.. automodule:: torchflows.bijections.finite.autoregressive.architectures - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.finite.autoregressive.conditioner\_transforms module --------------------------------------------------------------------------- - -.. automodule:: torchflows.bijections.finite.autoregressive.conditioner_transforms - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.finite.autoregressive.layers module ---------------------------------------------------------- - -.. automodule:: torchflows.bijections.finite.autoregressive.layers - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.finite.autoregressive.layers\_base module ---------------------------------------------------------------- - -.. automodule:: torchflows.bijections.finite.autoregressive.layers_base - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.finite.autoregressive.util module -------------------------------------------------------- - -.. automodule:: torchflows.bijections.finite.autoregressive.util - :members: - :undoc-members: - :show-inheritance: - -Module contents ---------------- - -.. automodule:: torchflows.bijections.finite.autoregressive - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/torchflows.bijections.finite.autoregressive.transformers.combination.rst b/docs/torchflows.bijections.finite.autoregressive.transformers.combination.rst deleted file mode 100644 index 9bca584..0000000 --- a/docs/torchflows.bijections.finite.autoregressive.transformers.combination.rst +++ /dev/null @@ -1,37 +0,0 @@ -torchflows.bijections.finite.autoregressive.transformers.combination package -============================================================================ - -Submodules ----------- - -torchflows.bijections.finite.autoregressive.transformers.combination.base module --------------------------------------------------------------------------------- - -.. automodule:: torchflows.bijections.finite.autoregressive.transformers.combination.base - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.finite.autoregressive.transformers.combination.sigmoid module ------------------------------------------------------------------------------------ - -.. automodule:: torchflows.bijections.finite.autoregressive.transformers.combination.sigmoid - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.finite.autoregressive.transformers.combination.sigmoid\_util module ------------------------------------------------------------------------------------------ - -.. automodule:: torchflows.bijections.finite.autoregressive.transformers.combination.sigmoid_util - :members: - :undoc-members: - :show-inheritance: - -Module contents ---------------- - -.. automodule:: torchflows.bijections.finite.autoregressive.transformers.combination - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/torchflows.bijections.finite.autoregressive.transformers.integration.rst b/docs/torchflows.bijections.finite.autoregressive.transformers.integration.rst deleted file mode 100644 index a4e33cb..0000000 --- a/docs/torchflows.bijections.finite.autoregressive.transformers.integration.rst +++ /dev/null @@ -1,29 +0,0 @@ -torchflows.bijections.finite.autoregressive.transformers.integration package -============================================================================ - -Submodules ----------- - -torchflows.bijections.finite.autoregressive.transformers.integration.base module --------------------------------------------------------------------------------- - -.. automodule:: torchflows.bijections.finite.autoregressive.transformers.integration.base - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.finite.autoregressive.transformers.integration.unconstrained\_monotonic\_neural\_network module ---------------------------------------------------------------------------------------------------------------------- - -.. automodule:: torchflows.bijections.finite.autoregressive.transformers.integration.unconstrained_monotonic_neural_network - :members: - :undoc-members: - :show-inheritance: - -Module contents ---------------- - -.. automodule:: torchflows.bijections.finite.autoregressive.transformers.integration - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/torchflows.bijections.finite.autoregressive.transformers.linear.rst b/docs/torchflows.bijections.finite.autoregressive.transformers.linear.rst deleted file mode 100644 index bae30ce..0000000 --- a/docs/torchflows.bijections.finite.autoregressive.transformers.linear.rst +++ /dev/null @@ -1,37 +0,0 @@ -torchflows.bijections.finite.autoregressive.transformers.linear package -======================================================================= - -Submodules ----------- - -torchflows.bijections.finite.autoregressive.transformers.linear.affine module ------------------------------------------------------------------------------ - -.. automodule:: torchflows.bijections.finite.autoregressive.transformers.linear.affine - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.finite.autoregressive.transformers.linear.convolution module ----------------------------------------------------------------------------------- - -.. automodule:: torchflows.bijections.finite.autoregressive.transformers.linear.convolution - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.finite.autoregressive.transformers.linear.matrix module ------------------------------------------------------------------------------ - -.. automodule:: torchflows.bijections.finite.autoregressive.transformers.linear.matrix - :members: - :undoc-members: - :show-inheritance: - -Module contents ---------------- - -.. automodule:: torchflows.bijections.finite.autoregressive.transformers.linear - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/torchflows.bijections.finite.autoregressive.transformers.rst b/docs/torchflows.bijections.finite.autoregressive.transformers.rst deleted file mode 100644 index 8649231..0000000 --- a/docs/torchflows.bijections.finite.autoregressive.transformers.rst +++ /dev/null @@ -1,32 +0,0 @@ -torchflows.bijections.finite.autoregressive.transformers package -================================================================ - -Subpackages ------------ - -.. toctree:: - :maxdepth: 4 - - torchflows.bijections.finite.autoregressive.transformers.combination - torchflows.bijections.finite.autoregressive.transformers.integration - torchflows.bijections.finite.autoregressive.transformers.linear - torchflows.bijections.finite.autoregressive.transformers.spline - -Submodules ----------- - -torchflows.bijections.finite.autoregressive.transformers.base module --------------------------------------------------------------------- - -.. automodule:: torchflows.bijections.finite.autoregressive.transformers.base - :members: - :undoc-members: - :show-inheritance: - -Module contents ---------------- - -.. automodule:: torchflows.bijections.finite.autoregressive.transformers - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/torchflows.bijections.finite.autoregressive.transformers.spline.rst b/docs/torchflows.bijections.finite.autoregressive.transformers.spline.rst deleted file mode 100644 index fbb80d0..0000000 --- a/docs/torchflows.bijections.finite.autoregressive.transformers.spline.rst +++ /dev/null @@ -1,61 +0,0 @@ -torchflows.bijections.finite.autoregressive.transformers.spline package -======================================================================= - -Submodules ----------- - -torchflows.bijections.finite.autoregressive.transformers.spline.base module ---------------------------------------------------------------------------- - -.. automodule:: torchflows.bijections.finite.autoregressive.transformers.spline.base - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.finite.autoregressive.transformers.spline.basis module ----------------------------------------------------------------------------- - -.. automodule:: torchflows.bijections.finite.autoregressive.transformers.spline.basis - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.finite.autoregressive.transformers.spline.cubic module ----------------------------------------------------------------------------- - -.. automodule:: torchflows.bijections.finite.autoregressive.transformers.spline.cubic - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.finite.autoregressive.transformers.spline.linear module ------------------------------------------------------------------------------ - -.. automodule:: torchflows.bijections.finite.autoregressive.transformers.spline.linear - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.finite.autoregressive.transformers.spline.linear\_rational module ---------------------------------------------------------------------------------------- - -.. automodule:: torchflows.bijections.finite.autoregressive.transformers.spline.linear_rational - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.finite.autoregressive.transformers.spline.rational\_quadratic module ------------------------------------------------------------------------------------------- - -.. automodule:: torchflows.bijections.finite.autoregressive.transformers.spline.rational_quadratic - :members: - :undoc-members: - :show-inheritance: - -Module contents ---------------- - -.. automodule:: torchflows.bijections.finite.autoregressive.transformers.spline - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/torchflows.bijections.finite.multiscale.rst b/docs/torchflows.bijections.finite.multiscale.rst deleted file mode 100644 index 3e15029..0000000 --- a/docs/torchflows.bijections.finite.multiscale.rst +++ /dev/null @@ -1,45 +0,0 @@ -torchflows.bijections.finite.multiscale package -=============================================== - -Submodules ----------- - -torchflows.bijections.finite.multiscale.architectures module ------------------------------------------------------------- - -.. automodule:: torchflows.bijections.finite.multiscale.architectures - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.finite.multiscale.base module ---------------------------------------------------- - -.. automodule:: torchflows.bijections.finite.multiscale.base - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.finite.multiscale.coupling module -------------------------------------------------------- - -.. automodule:: torchflows.bijections.finite.multiscale.coupling - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.finite.multiscale.layers module ------------------------------------------------------ - -.. automodule:: torchflows.bijections.finite.multiscale.layers - :members: - :undoc-members: - :show-inheritance: - -Module contents ---------------- - -.. automodule:: torchflows.bijections.finite.multiscale - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/torchflows.bijections.finite.residual.rst b/docs/torchflows.bijections.finite.residual.rst deleted file mode 100644 index 1a50566..0000000 --- a/docs/torchflows.bijections.finite.residual.rst +++ /dev/null @@ -1,85 +0,0 @@ -torchflows.bijections.finite.residual package -============================================= - -Submodules ----------- - -torchflows.bijections.finite.residual.architectures module ----------------------------------------------------------- - -.. automodule:: torchflows.bijections.finite.residual.architectures - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.finite.residual.base module -------------------------------------------------- - -.. automodule:: torchflows.bijections.finite.residual.base - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.finite.residual.iterative module ------------------------------------------------------- - -.. automodule:: torchflows.bijections.finite.residual.iterative - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.finite.residual.log\_abs\_det\_estimators module ----------------------------------------------------------------------- - -.. automodule:: torchflows.bijections.finite.residual.log_abs_det_estimators - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.finite.residual.planar module ---------------------------------------------------- - -.. automodule:: torchflows.bijections.finite.residual.planar - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.finite.residual.proximal module ------------------------------------------------------ - -.. automodule:: torchflows.bijections.finite.residual.proximal - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.finite.residual.quasi\_autoregressive module ------------------------------------------------------------------- - -.. automodule:: torchflows.bijections.finite.residual.quasi_autoregressive - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.finite.residual.radial module ---------------------------------------------------- - -.. automodule:: torchflows.bijections.finite.residual.radial - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.finite.residual.sylvester module ------------------------------------------------------- - -.. automodule:: torchflows.bijections.finite.residual.sylvester - :members: - :undoc-members: - :show-inheritance: - -Module contents ---------------- - -.. automodule:: torchflows.bijections.finite.residual - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/torchflows.bijections.finite.rst b/docs/torchflows.bijections.finite.rst deleted file mode 100644 index 4fb9565..0000000 --- a/docs/torchflows.bijections.finite.rst +++ /dev/null @@ -1,31 +0,0 @@ -torchflows.bijections.finite package -==================================== - -Subpackages ------------ - -.. toctree:: - :maxdepth: 4 - - torchflows.bijections.finite.autoregressive - torchflows.bijections.finite.multiscale - torchflows.bijections.finite.residual - -Submodules ----------- - -torchflows.bijections.finite.linear module ------------------------------------------- - -.. automodule:: torchflows.bijections.finite.linear - :members: - :undoc-members: - :show-inheritance: - -Module contents ---------------- - -.. automodule:: torchflows.bijections.finite - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/torchflows.bijections.rst b/docs/torchflows.bijections.rst deleted file mode 100644 index 7aab849..0000000 --- a/docs/torchflows.bijections.rst +++ /dev/null @@ -1,46 +0,0 @@ -torchflows.bijections package -============================= - -Subpackages ------------ - -.. toctree:: - :maxdepth: 4 - - torchflows.bijections.continuous - torchflows.bijections.finite - -Submodules ----------- - -torchflows.bijections.base module ---------------------------------- - -.. automodule:: torchflows.bijections.base - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.matrices module -------------------------------------- - -.. automodule:: torchflows.bijections.matrices - :members: - :undoc-members: - :show-inheritance: - -torchflows.bijections.numerical\_inversion module -------------------------------------------------- - -.. automodule:: torchflows.bijections.numerical_inversion - :members: - :undoc-members: - :show-inheritance: - -Module contents ---------------- - -.. automodule:: torchflows.bijections - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/torchflows.neural_networks.rst b/docs/torchflows.neural_networks.rst deleted file mode 100644 index ab45ab7..0000000 --- a/docs/torchflows.neural_networks.rst +++ /dev/null @@ -1,29 +0,0 @@ -torchflows.neural\_networks package -=================================== - -Submodules ----------- - -torchflows.neural\_networks.convnet module ------------------------------------------- - -.. automodule:: torchflows.neural_networks.convnet - :members: - :undoc-members: - :show-inheritance: - -torchflows.neural\_networks.resnet module ------------------------------------------ - -.. automodule:: torchflows.neural_networks.resnet - :members: - :undoc-members: - :show-inheritance: - -Module contents ---------------- - -.. automodule:: torchflows.neural_networks - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/torchflows.rst b/docs/torchflows.rst deleted file mode 100644 index c5b972c..0000000 --- a/docs/torchflows.rst +++ /dev/null @@ -1,55 +0,0 @@ -torchflows package -================== - -Subpackages ------------ - -.. toctree:: - :maxdepth: 4 - - torchflows.base_distributions - torchflows.bijections - torchflows.neural_networks - -Submodules ----------- - -torchflows.architectures module -------------------------------- - -.. automodule:: torchflows.architectures - :members: - :undoc-members: - :show-inheritance: - -torchflows.flows module ------------------------ - -.. automodule:: torchflows.flows - :members: - :undoc-members: - :show-inheritance: - -torchflows.regularization module --------------------------------- - -.. automodule:: torchflows.regularization - :members: - :undoc-members: - :show-inheritance: - -torchflows.utils module ------------------------ - -.. automodule:: torchflows.utils - :members: - :undoc-members: - :show-inheritance: - -Module contents ---------------- - -.. automodule:: torchflows - :members: - :undoc-members: - :show-inheritance: From eb12968d4c3c1230fd5a1b1dc31dfa0205143a1b Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Wed, 14 Aug 2024 09:28:18 +0200 Subject: [PATCH 13/39] Update docs --- docs/source/architectures.rst | 2 +- docs/source/basic_usage.rst | 29 +++++++++++++++++++++++ docs/source/conf.py | 3 --- docs/source/event_shapes.rst | 2 ++ docs/source/flow.rst | 2 +- docs/source/image_modeling.rst | 2 ++ docs/source/index.rst | 25 ++++++++++++++++---- docs/source/installing.rst | 30 ++++++++++++++++++++++++ docs/source/multiscale_architectures.rst | 2 +- docs/source/usage.rst | 15 +++++------- torchflows/architectures.py | 1 + 11 files changed, 93 insertions(+), 20 deletions(-) create mode 100644 docs/source/basic_usage.rst create mode 100644 docs/source/event_shapes.rst create mode 100644 docs/source/image_modeling.rst create mode 100644 docs/source/installing.rst diff --git a/docs/source/architectures.rst b/docs/source/architectures.rst index 945fd04..6045a40 100644 --- a/docs/source/architectures.rst +++ b/docs/source/architectures.rst @@ -1,4 +1,4 @@ -Flow architectures +Bijection architectures ============================ .. _architectures: diff --git a/docs/source/basic_usage.rst b/docs/source/basic_usage.rst new file mode 100644 index 0000000..bdb6130 --- /dev/null +++ b/docs/source/basic_usage.rst @@ -0,0 +1,29 @@ +Basic usage +============== + +Torchflow models learn the distributions of unlabeled data. We provide an example on how to train a normalizing 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/conf.py b/docs/source/conf.py index cc5474f..8ba94af 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -25,13 +25,10 @@ 'sphinx.ext.autosummary', ] -templates_path = ['_templates'] 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' -html_static_path = ['_static'] - epub_show_urls = 'footnote' diff --git a/docs/source/event_shapes.rst b/docs/source/event_shapes.rst new file mode 100644 index 0000000..ec72c42 --- /dev/null +++ b/docs/source/event_shapes.rst @@ -0,0 +1,2 @@ +Custom event shapes +====================== \ No newline at end of file diff --git a/docs/source/flow.rst b/docs/source/flow.rst index 5830f6a..2f9fcde 100644 --- a/docs/source/flow.rst +++ b/docs/source/flow.rst @@ -1,4 +1,4 @@ -Creating a Flow object +Flow objects =============================== The `Flow` object contains a base distribution and a bijection. diff --git a/docs/source/image_modeling.rst b/docs/source/image_modeling.rst new file mode 100644 index 0000000..4153480 --- /dev/null +++ b/docs/source/image_modeling.rst @@ -0,0 +1,2 @@ +Image modeling +============== \ No newline at end of file diff --git a/docs/source/index.rst b/docs/source/index.rst index d4cc6d3..a421f6a 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -6,12 +6,27 @@ Torchflows documentation ======================== -Check out the :doc:`usage` section for more information, including how to :ref:`install ` Torchflows. +Torchflows is a library for generative modeling and density estimation using normalizing flows. +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. + +Installing +--------------- +Torchflows can be installed easily using pip: + +.. code-block:: console + + pip install torchflows + +For other install options, see the :ref:`install ` section. .. toctree:: - usage - flow - architectures - multiscale_architectures + installing + usage + flow + architectures + multiscale_architectures diff --git a/docs/source/installing.rst b/docs/source/installing.rst new file mode 100644 index 0000000..ded9336 --- /dev/null +++ b/docs/source/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/multiscale_architectures.rst b/docs/source/multiscale_architectures.rst index c0aef0d..327668e 100644 --- a/docs/source/multiscale_architectures.rst +++ b/docs/source/multiscale_architectures.rst @@ -1,4 +1,4 @@ -Multiscale flow architectures +Multiscale bijetion architectures ============================ .. _multiscale_architectures: diff --git a/docs/source/usage.rst b/docs/source/usage.rst index 26c7ab9..1cdd2d5 100644 --- a/docs/source/usage.rst +++ b/docs/source/usage.rst @@ -1,13 +1,10 @@ Usage -============== +=========== -.. _installation: +We provide tutorials and notebooks for typical Torchflows use cases. -Installation ----------------------- +.. toctree:: -Install Torchflows using pip: - -.. code-block:: console - - pip install torchflows + basic_usage + event_shapes + image_modeling \ No newline at end of file diff --git a/torchflows/architectures.py b/torchflows/architectures.py index d0c59f6..77fa248 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, From 8e6c76c316ebdf0a59752f21175bd6810395528a Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Wed, 14 Aug 2024 09:30:21 +0200 Subject: [PATCH 14/39] Add requirements.txt for sphinx --- docs/requirements.txt | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 docs/requirements.txt diff --git a/docs/requirements.txt b/docs/requirements.txt new file mode 100644 index 0000000..1d628f2 --- /dev/null +++ b/docs/requirements.txt @@ -0,0 +1,2 @@ +sphinx==7.1.2 +sphinx-rtd-theme==1.3.0rc1 \ No newline at end of file From 73cad4b31713868785afc65e90e42832d25cbfa1 Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Wed, 14 Aug 2024 09:33:36 +0200 Subject: [PATCH 15/39] Add torchflows to requirements.txt for sphinx --- docs/requirements.txt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/docs/requirements.txt b/docs/requirements.txt index 1d628f2..1876a8f 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -1,2 +1,3 @@ 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 \ No newline at end of file From cd23c3cddd97ef007466187ddd7a20da9a83b197 Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Wed, 14 Aug 2024 09:39:23 +0200 Subject: [PATCH 16/39] Fix typo, remove torchflows from requirements.txt --- docs/requirements.txt | 3 +-- docs/source/multiscale_architectures.rst | 2 +- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/docs/requirements.txt b/docs/requirements.txt index 1876a8f..1d628f2 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -1,3 +1,2 @@ sphinx==7.1.2 -sphinx-rtd-theme==1.3.0rc1 -torchflows>=1.0.2 \ No newline at end of file +sphinx-rtd-theme==1.3.0rc1 \ No newline at end of file diff --git a/docs/source/multiscale_architectures.rst b/docs/source/multiscale_architectures.rst index 327668e..3b4afcb 100644 --- a/docs/source/multiscale_architectures.rst +++ b/docs/source/multiscale_architectures.rst @@ -1,4 +1,4 @@ -Multiscale bijetion architectures +Multiscale bijection architectures ============================ .. _multiscale_architectures: From 7eb1d935608a116e06d78b640dbc7c161d4e3d14 Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Wed, 14 Aug 2024 09:49:32 +0200 Subject: [PATCH 17/39] Add torchflows to requirements.txt --- docs/requirements.txt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/docs/requirements.txt b/docs/requirements.txt index 1d628f2..1876a8f 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -1,2 +1,3 @@ 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 \ No newline at end of file From d87bce377a41192a6cf2437fbaeb700fd4de92fc Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Wed, 14 Aug 2024 09:49:44 +0200 Subject: [PATCH 18/39] Fix underline length --- docs/source/multiscale_architectures.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/multiscale_architectures.rst b/docs/source/multiscale_architectures.rst index 3b4afcb..816a1e7 100644 --- a/docs/source/multiscale_architectures.rst +++ b/docs/source/multiscale_architectures.rst @@ -1,5 +1,5 @@ Multiscale bijection architectures -============================ +======================================================== .. _multiscale_architectures: From 7f80493dbe8f325fe25f785e4b024680203f4c94 Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Wed, 14 Aug 2024 09:49:51 +0200 Subject: [PATCH 19/39] Add copy button --- docs/source/conf.py | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/source/conf.py b/docs/source/conf.py index 8ba94af..bc399a8 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -23,6 +23,7 @@ 'sphinx.ext.doctest', 'sphinx.ext.autodoc', 'sphinx.ext.autosummary', + 'sphinx_copybutton', ] exclude_patterns = [] From f65ca4c18ca1f46ed2215c0969e612345c3c972d Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Wed, 14 Aug 2024 09:52:12 +0200 Subject: [PATCH 20/39] Update requirements.txt --- docs/requirements.txt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/docs/requirements.txt b/docs/requirements.txt index 1876a8f..f169e70 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -1,3 +1,4 @@ sphinx==7.1.2 sphinx-rtd-theme==1.3.0rc1 -torchflows>=1.0.2 \ No newline at end of file +torchflows>=1.0.2 +sphinx-copybutton \ No newline at end of file From b8a7001589da61c88d76d4526834661cd582d9cb Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Wed, 14 Aug 2024 10:41:31 +0200 Subject: [PATCH 21/39] Update docs --- docs/source/flow.rst | 7 ++- docs/source/index.rst | 3 ++ torchflows/flows.py | 122 +++++++++++++++++++++++++----------------- 3 files changed, 82 insertions(+), 50 deletions(-) diff --git a/docs/source/flow.rst b/docs/source/flow.rst index 2f9fcde..0fe1d1d 100644 --- a/docs/source/flow.rst +++ b/docs/source/flow.rst @@ -4,6 +4,11 @@ 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 \ No newline at end of file +.. autoclass:: torchflows.flows.FlowMixture + :members: __init__, log_prob, sample \ No newline at end of file diff --git a/docs/source/index.rst b/docs/source/index.rst index a421f6a..6960b48 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -22,6 +22,9 @@ Torchflows can be installed easily using pip: For other install options, see the :ref:`install ` section. +Contents +========= + .. toctree:: installing diff --git a/torchflows/flows.py b/torchflows/flows.py index 23355d3..39aa4df 100644 --- a/torchflows/flows.py +++ b/torchflows/flows.py @@ -10,15 +10,13 @@ class BaseFlow(nn.Module): - """ - Base normalizing flow class. + """Base normalizing flow class. """ def __init__(self, event_shape, base_distribution: Union[torch.distributions.Distribution, str] = 'standard_normal'): - """ - BaseFlow constructor. + """BaseFlow constructor. :param event_shape: shape of the event space. :param base_distribution: base distribution. @@ -40,14 +38,12 @@ def __init__(self, self.device_buffer = torch.empty(size=()) def get_device(self): - """ - Returns the torch device for this object. + """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. @@ -57,8 +53,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. @@ -68,8 +63,7 @@ def base_sample(self, sample_shape: Union[torch.Size, Tuple[int, ...]]): return z def regularization(self): - """ - Compute the regularization term used in training. + """Compute the regularization term used in training. """ return 0.0 @@ -88,24 +82,23 @@ def fit(self, keep_best_weights: bool = True, early_stopping: bool = False, early_stopping_threshold: int = 50): - """ - Fit the normalizing flow to a dataset. + """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. @@ -262,18 +255,16 @@ def variational_fit(self, early_stopping_threshold: int = 50, keep_best_weights: bool = True, show_progress: bool = False): - """ - Train the normalizing flow to fit a target log probability. + """Train the normalizing flow to fit a target log probability. 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). + (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. @@ -316,30 +307,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] @@ -348,13 +338,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] @@ -362,17 +352,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,) @@ -381,7 +372,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) @@ -409,7 +400,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 @@ -426,7 +430,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) @@ -435,7 +446,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: From 61a904337fc020fdbd6e1c48ff81b29b7de99f99 Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Wed, 14 Aug 2024 11:05:57 +0200 Subject: [PATCH 22/39] Add references and docstrings for autoregressive flows --- docs/source/architectures.rst | 2 + .../finite/autoregressive/architectures.py | 51 +++++++++++++++++-- 2 files changed, 49 insertions(+), 4 deletions(-) diff --git a/docs/source/architectures.rst b/docs/source/architectures.rst index 6045a40..959a092 100644 --- a/docs/source/architectures.rst +++ b/docs/source/architectures.rst @@ -1,5 +1,7 @@ Bijection architectures ============================ +We lists notable implemented bijection architectures. +These all inherit from the Bijection class. .. _architectures: 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,) From b8d79c9eeb7a17a2452fb2d184587a9ebb74b91c Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Wed, 14 Aug 2024 11:10:05 +0200 Subject: [PATCH 23/39] Rename headers --- docs/source/architectures.rst | 2 +- docs/source/multiscale_architectures.rst | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/source/architectures.rst b/docs/source/architectures.rst index 959a092..c539b7e 100644 --- a/docs/source/architectures.rst +++ b/docs/source/architectures.rst @@ -1,4 +1,4 @@ -Bijection architectures +Standard architectures ============================ We lists notable implemented bijection architectures. These all inherit from the Bijection class. diff --git a/docs/source/multiscale_architectures.rst b/docs/source/multiscale_architectures.rst index 816a1e7..9f6d1ba 100644 --- a/docs/source/multiscale_architectures.rst +++ b/docs/source/multiscale_architectures.rst @@ -1,4 +1,4 @@ -Multiscale bijection architectures +Multiscale architectures ======================================================== .. _multiscale_architectures: From 3cd5804bbc0d2ea534fbc313b4c774f12f34afdf Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Wed, 14 Aug 2024 11:29:14 +0200 Subject: [PATCH 24/39] Add bijection docs --- docs/source/bijections.rst | 18 ++++++++++++ docs/source/index.rst | 8 +++++- torchflows/bijections/base.py | 53 ++++++++++++++++++++++++----------- 3 files changed, 61 insertions(+), 18 deletions(-) create mode 100644 docs/source/bijections.rst diff --git a/docs/source/bijections.rst b/docs/source/bijections.rst new file mode 100644 index 0000000..5c28bc9 --- /dev/null +++ b/docs/source/bijections.rst @@ -0,0 +1,18 @@ +Bijections +============ + +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__ + +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/index.rst b/docs/source/index.rst index 6960b48..3c88433 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -22,14 +22,20 @@ Torchflows can be installed easily using pip: For other install options, see the :ref:`install ` section. -Contents +Guides ========= .. toctree:: installing usage + +API +==== + +.. toctree:: flow + bijections architectures multiscale_architectures diff --git a/torchflows/bijections/base.py b/torchflows/bijections/base.py index c161084..218de6f 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,20 +90,34 @@ 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) From e2090b29c02f80f105033bd7fae5e0fd06981c7b Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Wed, 14 Aug 2024 11:33:29 +0200 Subject: [PATCH 25/39] Use section in rst --- docs/source/bijections.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/bijections.rst b/docs/source/bijections.rst index 5c28bc9..95cabec 100644 --- a/docs/source/bijections.rst +++ b/docs/source/bijections.rst @@ -11,7 +11,7 @@ The following classes define forward and inverse pass methods which all flow arc :members: __init__ Inverting a bijection -====================== +--------------------- Each bijection can be inverted with the `invert` function. From cf770f7ecb80de0fe9b6ef7b6e96e88c59fdaaab Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Wed, 14 Aug 2024 11:51:24 +0200 Subject: [PATCH 26/39] Add continuous NF docs --- torchflows/bijections/continuous/ddnf.py | 18 +++++++++--------- torchflows/bijections/continuous/ffjord.py | 4 ++++ torchflows/bijections/continuous/otflow.py | 5 +++++ torchflows/bijections/continuous/rnode.py | 4 ++++ 4 files changed, 22 insertions(+), 9 deletions(-) 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..03c2e8e 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: Chen et al. "Neural Ordinary Differential Equations" (2019); https://arxiv.org/abs/1806.07366. + """ 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") From 59a4e539f0a823f0317cb7e9dd70b860cf4a5367 Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Wed, 14 Aug 2024 12:08:08 +0200 Subject: [PATCH 27/39] Add continuous bijection docs --- docs/source/bijections.rst | 3 +++ torchflows/bijections/continuous/base.py | 30 ++++++++++++++++++----- torchflows/bijections/continuous/rnode.py | 2 +- 3 files changed, 28 insertions(+), 7 deletions(-) diff --git a/docs/source/bijections.rst b/docs/source/bijections.rst index 95cabec..37aa08f 100644 --- a/docs/source/bijections.rst +++ b/docs/source/bijections.rst @@ -10,6 +10,9 @@ The following classes define forward and inverse pass methods which all flow arc .. autoclass:: torchflows.bijections.base.BijectiveComposition :members: __init__ +.. autoclass:: torchflows.bijections.continuous.base.ContinuousBijection + :members: __init__, forward, inverse + Inverting a bijection --------------------- 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/rnode.py b/torchflows/bijections/continuous/rnode.py index 03c2e8e..66d5aa5 100644 --- a/torchflows/bijections/continuous/rnode.py +++ b/torchflows/bijections/continuous/rnode.py @@ -10,7 +10,7 @@ class RNODE(ApproximateContinuousBijection): """Regularized neural ordinary differential equation (RNODE) architecture. - Reference: Chen et al. "Neural Ordinary Differential Equations" (2019); https://arxiv.org/abs/1806.07366. + 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))) From f5cdad23d89a13a3a158121623b5db9232db0b22 Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Wed, 14 Aug 2024 12:10:19 +0200 Subject: [PATCH 28/39] Separate architectures by type --- docs/source/architectures.rst | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/docs/source/architectures.rst b/docs/source/architectures.rst index c539b7e..da4e074 100644 --- a/docs/source/architectures.rst +++ b/docs/source/architectures.rst @@ -5,6 +5,9 @@ These all inherit from the Bijection class. .. _architectures: +Autoregressive architectures +-------------------------------- + .. autoclass:: torchflows.architectures.RealNVP .. autoclass:: torchflows.architectures.InverseRealNVP .. autoclass:: torchflows.architectures.NICE @@ -17,10 +20,16 @@ These all inherit from the Bijection class. .. 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 From eff1a1534631b730c0157eb0ea5cbd61d346f45c Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Wed, 14 Aug 2024 12:22:12 +0200 Subject: [PATCH 29/39] Add residual flow docs --- docs/source/architectures.rst | 6 ++-- torchflows/architectures.py | 6 ++-- .../finite/residual/architectures.py | 30 +++++++++++++++++++ 3 files changed, 36 insertions(+), 6 deletions(-) diff --git a/docs/source/architectures.rst b/docs/source/architectures.rst index da4e074..73b9613 100644 --- a/docs/source/architectures.rst +++ b/docs/source/architectures.rst @@ -33,6 +33,6 @@ Residual architectures .. autoclass:: torchflows.architectures.ResFlow .. autoclass:: torchflows.architectures.ProximalResFlow .. autoclass:: torchflows.architectures.InvertibleResNet -.. autoclass:: torchflows.architectures.Planar -.. autoclass:: torchflows.architectures.Radial -.. autoclass:: torchflows.architectures.Sylvester \ No newline at end of file +.. autoclass:: torchflows.architectures.PlanarFlow +.. autoclass:: torchflows.architectures.RadialFlow +.. autoclass:: torchflows.architectures.SylvesterFlow \ No newline at end of file diff --git a/torchflows/architectures.py b/torchflows/architectures.py index 77fa248..265c842 100644 --- a/torchflows/architectures.py +++ b/torchflows/architectures.py @@ -22,9 +22,9 @@ ResFlow, ProximalResFlow, InvertibleResNet, - Planar, - Radial, - Sylvester + PlanarFlow, + RadialFlow, + SylvesterFlow ) from torchflows.bijections.finite.multiscale.architectures import ( diff --git a/torchflows/bijections/finite/residual/architectures.py b/torchflows/bijections/finite/residual/architectures.py index 7795a17..d44194d 100644 --- a/torchflows/bijections/finite/residual/architectures.py +++ b/torchflows/bijections/finite/residual/architectures.py @@ -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}") From 94b88c4529cf29bd722881529150de54c59a8441 Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Wed, 14 Aug 2024 13:09:59 +0200 Subject: [PATCH 30/39] Update docs --- docs/requirements.txt | 3 +- docs/source/{ => api}/architectures.rst | 0 docs/source/api/base_distributions.rst | 2 + docs/source/{ => api}/bijections.rst | 7 ++- docs/source/api/components.rst | 7 +++ docs/source/{ => api}/flow.rst | 0 .../{ => api}/multiscale_architectures.rst | 4 +- docs/source/basic_usage.rst | 29 ------------ docs/source/guides/basic_usage.rst | 45 +++++++++++++++++++ .../guides/choosing_base_distributions.rst | 2 + docs/source/{ => guides}/event_shapes.rst | 2 +- docs/source/{ => guides}/image_modeling.rst | 0 docs/source/{ => guides}/installing.rst | 0 docs/source/{ => guides}/usage.rst | 5 ++- docs/source/index.rst | 11 +++-- .../finite/multiscale/architectures.py | 22 +++++++++ .../bijections/finite/multiscale/base.py | 14 ++++++ 17 files changed, 111 insertions(+), 42 deletions(-) rename docs/source/{ => api}/architectures.rst (100%) create mode 100644 docs/source/api/base_distributions.rst rename docs/source/{ => api}/bijections.rst (80%) create mode 100644 docs/source/api/components.rst rename docs/source/{ => api}/flow.rst (100%) rename docs/source/{ => api}/multiscale_architectures.rst (71%) delete mode 100644 docs/source/basic_usage.rst create mode 100644 docs/source/guides/basic_usage.rst create mode 100644 docs/source/guides/choosing_base_distributions.rst rename docs/source/{ => guides}/event_shapes.rst (51%) rename docs/source/{ => guides}/image_modeling.rst (100%) rename docs/source/{ => guides}/installing.rst (100%) rename docs/source/{ => guides}/usage.rst (68%) diff --git a/docs/requirements.txt b/docs/requirements.txt index f169e70..2c4c704 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -1,4 +1,5 @@ sphinx==7.1.2 sphinx-rtd-theme==1.3.0rc1 torchflows>=1.0.2 -sphinx-copybutton \ No newline at end of file +sphinx-copybutton +nbsphinx \ No newline at end of file diff --git a/docs/source/architectures.rst b/docs/source/api/architectures.rst similarity index 100% rename from docs/source/architectures.rst rename to docs/source/api/architectures.rst diff --git a/docs/source/api/base_distributions.rst b/docs/source/api/base_distributions.rst new file mode 100644 index 0000000..2421e93 --- /dev/null +++ b/docs/source/api/base_distributions.rst @@ -0,0 +1,2 @@ +Base distribution objects +========================== \ No newline at end of file diff --git a/docs/source/bijections.rst b/docs/source/api/bijections.rst similarity index 80% rename from docs/source/bijections.rst rename to docs/source/api/bijections.rst index 37aa08f..2be7d28 100644 --- a/docs/source/bijections.rst +++ b/docs/source/api/bijections.rst @@ -1,5 +1,5 @@ -Bijections -============ +Bijection objects +==================== All normalizing flow transformations are bijections. The following classes define forward and inverse pass methods which all flow architectures inherit. @@ -13,6 +13,9 @@ The following classes define forward and inverse pass methods which all flow arc .. autoclass:: torchflows.bijections.continuous.base.ContinuousBijection :members: __init__, forward, inverse +.. autoclass:: torchflows.bijections.finite.multiscale.base.MultiscaleBijection + :members: __init__ + Inverting a bijection --------------------- 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/flow.rst b/docs/source/api/flow.rst similarity index 100% rename from docs/source/flow.rst rename to docs/source/api/flow.rst diff --git a/docs/source/multiscale_architectures.rst b/docs/source/api/multiscale_architectures.rst similarity index 71% rename from docs/source/multiscale_architectures.rst rename to docs/source/api/multiscale_architectures.rst index 9f6d1ba..b74d185 100644 --- a/docs/source/multiscale_architectures.rst +++ b/docs/source/api/multiscale_architectures.rst @@ -1,9 +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 \ No newline at end of file +.. autoclass:: torchflows.architectures.MultiscaleNICE diff --git a/docs/source/basic_usage.rst b/docs/source/basic_usage.rst deleted file mode 100644 index bdb6130..0000000 --- a/docs/source/basic_usage.rst +++ /dev/null @@ -1,29 +0,0 @@ -Basic usage -============== - -Torchflow models learn the distributions of unlabeled data. We provide an example on how to train a normalizing 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/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..70d7801 --- /dev/null +++ b/docs/source/guides/choosing_base_distributions.rst @@ -0,0 +1,2 @@ +Choosing a base distribution +============================== \ No newline at end of file diff --git a/docs/source/event_shapes.rst b/docs/source/guides/event_shapes.rst similarity index 51% rename from docs/source/event_shapes.rst rename to docs/source/guides/event_shapes.rst index ec72c42..28e0f63 100644 --- a/docs/source/event_shapes.rst +++ b/docs/source/guides/event_shapes.rst @@ -1,2 +1,2 @@ -Custom event shapes +Complex event shapes ====================== \ No newline at end of file diff --git a/docs/source/image_modeling.rst b/docs/source/guides/image_modeling.rst similarity index 100% rename from docs/source/image_modeling.rst rename to docs/source/guides/image_modeling.rst diff --git a/docs/source/installing.rst b/docs/source/guides/installing.rst similarity index 100% rename from docs/source/installing.rst rename to docs/source/guides/installing.rst diff --git a/docs/source/usage.rst b/docs/source/guides/usage.rst similarity index 68% rename from docs/source/usage.rst rename to docs/source/guides/usage.rst index 1cdd2d5..fd8cd2c 100644 --- a/docs/source/usage.rst +++ b/docs/source/guides/usage.rst @@ -1,4 +1,4 @@ -Usage +Examples =========== We provide tutorials and notebooks for typical Torchflows use cases. @@ -7,4 +7,5 @@ We provide tutorials and notebooks for typical Torchflows use cases. basic_usage event_shapes - image_modeling \ No newline at end of file + image_modeling + choosing_base_distributions \ No newline at end of file diff --git a/docs/source/index.rst b/docs/source/index.rst index 3c88433..bb5696f 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -27,15 +27,14 @@ Guides .. toctree:: - installing - usage + guides/installing + guides/usage API ==== .. toctree:: - flow - bijections - architectures - multiscale_architectures + api/components + api/architectures + api/multiscale_architectures diff --git a/torchflows/bijections/finite/multiscale/architectures.py b/torchflows/bijections/finite/multiscale/architectures.py index 2b84260..2a6dea4 100644 --- a/torchflows/bijections/finite/multiscale/architectures.py +++ b/torchflows/bijections/finite/multiscale/architectures.py @@ -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 1b75259..365c5d6 100644 --- a/torchflows/bijections/finite/multiscale/base.py +++ b/torchflows/bijections/finite/multiscale/base.py @@ -256,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], @@ -264,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, From a489c4624512e5480f167211f4cf419c517bb7fb Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Wed, 14 Aug 2024 13:35:38 +0200 Subject: [PATCH 31/39] Update docs --- README.md | 66 ++----------------- .../source/guides/mathematical_background.rst | 16 +++++ docs/source/guides/usage.rst | 3 +- docs/source/index.rst | 3 + 4 files changed, 28 insertions(+), 60 deletions(-) create mode 100644 docs/source/guides/mathematical_background.rst diff --git a/README.md b/README.md index 3fe5c48..016d1bd 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](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/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/usage.rst b/docs/source/guides/usage.rst index fd8cd2c..9b91ff6 100644 --- a/docs/source/guides/usage.rst +++ b/docs/source/guides/usage.rst @@ -5,7 +5,8 @@ We provide tutorials and notebooks for typical Torchflows use cases. .. toctree:: + mathematical_background basic_usage event_shapes image_modeling - choosing_base_distributions \ No newline at end of file + choosing_base_distributions diff --git a/docs/source/index.rst b/docs/source/index.rst index bb5696f..606b626 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -12,6 +12,9 @@ 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. +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: From e5e19384ae3a61a68f9c5be1252423d4e42f1a6d Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Wed, 14 Aug 2024 14:30:23 +0200 Subject: [PATCH 32/39] Fix CUDA support --- test/test_cuda.py | 8 ++------ torchflows/flows.py | 10 ++++------ 2 files changed, 6 insertions(+), 12 deletions(-) diff --git a/test/test_cuda.py b/test/test_cuda.py index e449291..888a08f 100644 --- a/test/test_cuda.py +++ b/test/test_cuda.py @@ -4,7 +4,6 @@ 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/torchflows/flows.py b/torchflows/flows.py index 39aa4df..53748c7 100644 --- a/torchflows/flows.py +++ b/torchflows/flows.py @@ -7,6 +7,7 @@ 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): @@ -26,16 +27,13 @@ def __init__(self, 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. @@ -261,7 +259,7 @@ def variational_fit(self, 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). - +w :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)`. From f30c137c4e7a9e03f6d8297eac8380376a9c5c3c Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Wed, 14 Aug 2024 14:30:40 +0200 Subject: [PATCH 33/39] Simplify device handling in BijectiveComposition --- torchflows/bijections/base.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/torchflows/bijections/base.py b/torchflows/bijections/base.py index 218de6f..23012fb 100644 --- a/torchflows/bijections/base.py +++ b/torchflows/bijections/base.py @@ -122,7 +122,7 @@ def __init__(self, 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 @@ -130,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 From ebd2d2386c7ed118e75eded3e474a35c85580ced Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Wed, 14 Aug 2024 14:38:36 +0200 Subject: [PATCH 34/39] Fix base distribution superclass init call --- torchflows/base_distributions/gaussian.py | 4 ++-- torchflows/base_distributions/mixture.py | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/torchflows/base_distributions/gaussian.py b/torchflows/base_distributions/gaussian.py index bc37342..70fb77d 100644 --- a/torchflows/base_distributions/gaussian.py +++ b/torchflows/base_distributions/gaussian.py @@ -11,7 +11,7 @@ def __init__(self, scale: torch.Tensor, trainable_loc: bool = False, trainable_scale: bool = False): - super().__init__(event_shape=loc.shape) + 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)) @@ -48,7 +48,7 @@ def __init__(self, loc: torch.Tensor, cov: torch.Tensor, trainable_loc: bool = False): - super().__init__(event_shape=loc.shape) + 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..284367a 100644 --- a/torchflows/base_distributions/mixture.py +++ b/torchflows/base_distributions/mixture.py @@ -13,7 +13,7 @@ def __init__(self, weights: torch.Tensor = None): 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) From 7e41564db6feb8f15def2a3d0806871dcce6f765 Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Wed, 14 Aug 2024 14:38:44 +0200 Subject: [PATCH 35/39] Fix docstring indent --- torchflows/flows.py | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/torchflows/flows.py b/torchflows/flows.py index 53748c7..8cc8362 100644 --- a/torchflows/flows.py +++ b/torchflows/flows.py @@ -255,11 +255,9 @@ def variational_fit(self, show_progress: bool = False): """Train the normalizing flow to fit a target log probability. - 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). -w + 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)`. From fb067f282ee0b7b8cf1f5ec0f98407c8631407b4 Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Wed, 14 Aug 2024 14:38:52 +0200 Subject: [PATCH 36/39] Update docs --- docs/source/guides/cuda.rst | 18 ++++++++++++++ docs/source/guides/event_shapes.rst | 24 +++++++++++++++++-- docs/source/guides/image_modeling.rst | 22 ++++++++++++++++- .../source/guides/{usage.rst => tutorial.rst} | 3 ++- docs/source/index.rst | 2 +- 5 files changed, 64 insertions(+), 5 deletions(-) create mode 100644 docs/source/guides/cuda.rst rename docs/source/guides/{usage.rst => tutorial.rst} (92%) 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 index 28e0f63..e2a62d3 100644 --- a/docs/source/guides/event_shapes.rst +++ b/docs/source/guides/event_shapes.rst @@ -1,2 +1,22 @@ -Complex event shapes -====================== \ No newline at end of file +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 index 4153480..757365e 100644 --- a/docs/source/guides/image_modeling.rst +++ b/docs/source/guides/image_modeling.rst @@ -1,2 +1,22 @@ Image modeling -============== \ No newline at end of file +============== + +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/usage.rst b/docs/source/guides/tutorial.rst similarity index 92% rename from docs/source/guides/usage.rst rename to docs/source/guides/tutorial.rst index 9b91ff6..f9f63b1 100644 --- a/docs/source/guides/usage.rst +++ b/docs/source/guides/tutorial.rst @@ -1,4 +1,4 @@ -Examples +Tutorial =========== We provide tutorials and notebooks for typical Torchflows use cases. @@ -10,3 +10,4 @@ We provide tutorials and notebooks for typical Torchflows use cases. event_shapes image_modeling choosing_base_distributions + cuda diff --git a/docs/source/index.rst b/docs/source/index.rst index 606b626..c21b83e 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -31,7 +31,7 @@ Guides .. toctree:: guides/installing - guides/usage + guides/tutorial API ==== From 27a58e2ebfd234f6539fa76b92a582c9711dd4cc Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Wed, 14 Aug 2024 15:01:20 +0200 Subject: [PATCH 37/39] Update docs for base distributions --- docs/source/api/base_distributions.rst | 14 ++++- .../guides/choosing_base_distributions.rst | 51 ++++++++++++++++++- torchflows/base_distributions/gaussian.py | 20 ++++++++ torchflows/base_distributions/mixture.py | 30 +++++++++++ 4 files changed, 113 insertions(+), 2 deletions(-) diff --git a/docs/source/api/base_distributions.rst b/docs/source/api/base_distributions.rst index 2421e93..174ba1e 100644 --- a/docs/source/api/base_distributions.rst +++ b/docs/source/api/base_distributions.rst @@ -1,2 +1,14 @@ Base distribution objects -========================== \ No newline at end of file +========================== + +.. 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/guides/choosing_base_distributions.rst b/docs/source/guides/choosing_base_distributions.rst index 70d7801..bc9e472 100644 --- a/docs/source/guides/choosing_base_distributions.rst +++ b/docs/source/guides/choosing_base_distributions.rst @@ -1,2 +1,51 @@ Choosing a base distribution -============================== \ No newline at end of file +============================== + +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/torchflows/base_distributions/gaussian.py b/torchflows/base_distributions/gaussian.py index 70fb77d..9ce1764 100644 --- a/torchflows/base_distributions/gaussian.py +++ b/torchflows/base_distributions/gaussian.py @@ -6,11 +6,21 @@ 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): + """ + 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: @@ -44,10 +54,20 @@ 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): + """ + 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): diff --git a/torchflows/base_distributions/mixture.py b/torchflows/base_distributions/mixture.py index 284367a..17f3a0f 100644 --- a/torchflows/base_distributions/mixture.py +++ b/torchflows/base_distributions/mixture.py @@ -8,9 +8,18 @@ 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, validate_args=False) @@ -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): From 73c8dde131e42e223fc992fe5d1923bac9404d03 Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Wed, 14 Aug 2024 15:05:30 +0200 Subject: [PATCH 38/39] Update index.rst --- docs/source/index.rst | 2 ++ 1 file changed, 2 insertions(+) diff --git a/docs/source/index.rst b/docs/source/index.rst index c21b83e..d2f9b46 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -37,6 +37,8 @@ API ==== .. toctree:: + :maxdepth: 3 + api/components api/architectures api/multiscale_architectures From 3b260d857cbe9f172c8ab617c79d5d7031fe1e88 Mon Sep 17 00:00:00 2001 From: David Nabergoj Date: Thu, 15 Aug 2024 03:45:06 +0200 Subject: [PATCH 39/39] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 016d1bd..4c86fe0 100644 --- a/README.md +++ b/README.md @@ -30,7 +30,7 @@ print(log_prob.shape) # (100,) print(x_new.shape) # (50, 3) ``` -Check examples and documentation, including the list of supported architectures [here](torchflows.readthedocs.io/en/latest/). +Check examples and documentation, including the list of supported architectures [here](https://torchflows.readthedocs.io/en/latest/). We also provide examples [here](examples/). ## Installing