From 6faab281d034b9c3feacbfd31b882b4cf4b37178 Mon Sep 17 00:00:00 2001
From: Dominika Zieba <2316440z@student.gla.ac.uk>
Date: Tue, 18 Mar 2025 15:39:22 +0000
Subject: [PATCH 1/7] Added a coupling flow with bernstein bijectors

---
 src/glasflow/flows/bpf.py            | 180 +++++++++++++++++++
 src/glasflow/transforms/bernstein.py | 248 +++++++++++++++++++++++++++
 2 files changed, 428 insertions(+)
 create mode 100644 src/glasflow/flows/bpf.py
 create mode 100644 src/glasflow/transforms/bernstein.py

diff --git a/src/glasflow/flows/bpf.py b/src/glasflow/flows/bpf.py
new file mode 100644
index 0000000..a01184b
--- /dev/null
+++ b/src/glasflow/flows/bpf.py
@@ -0,0 +1,180 @@
+# -*- coding: utf-8 -*-
+"""
+Implementation of Neural Spline Flows.
+
+See: https://arxiv.org/abs/1906.04032
+"""
+
+#from glasflow.nflows.transforms.coupling import PiecewiseBernsteinCouplingTransform
+from glasflow.nflows.transforms.coupling import PiecewiseCouplingTransform
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from .coupling import CouplingFlow
+
+from ..transforms.bernstein import bernstein_transform
+
+class PiecewiseBernsteinCouplingTransform(PiecewiseCouplingTransform):
+    def __init__(
+        self,
+        mask,
+        transform_net_create_fn,
+        bernstein_degree=10,
+        tails=None,
+        tail_bound=1.0,
+        apply_unconditional_transform=False,
+        log = False
+    ):
+
+        self.bernstein_degree = bernstein_degree 
+        self.tails = tails
+        self.tail_bound = tail_bound
+        self.log = log
+
+
+        if apply_unconditional_transform:
+            raise NotImplementedError()
+        
+        else:
+            unconditional_transform = None
+
+        super().__init__(
+            mask,
+            transform_net_create_fn,
+            unconditional_transform=unconditional_transform,
+        )
+
+    def _transform_dim_multiplier(self):
+        return self.bernstein_degree - 1
+
+    def _piecewise_cdf(self, inputs, transform_params, inverse=False):
+        unconstrained_alphas = transform_params
+
+        if hasattr(self.transform_net, "hidden_features"):
+            unconstrained_alphas /= np.sqrt(self.transform_net.hidden_features)
+        elif hasattr(self.transform_net, "hidden_channels"):
+            unconstrained_alphas /= np.sqrt(self.transform_net.hidden_channels)
+        else:
+            warnings.warn(
+                "Inputs to the softmax are not scaled down: initialization might be bad."
+            )
+
+        
+        if self.tails is None:
+             bijector_fn = bernstein_transform
+        else:
+            raise NotImplementedError()
+
+        return bijector_fn(
+            inputs=inputs,
+            unconstrained_alphas=unconstrained_alphas,
+            inverse=inverse, log=self.log)
+
+
+class CouplingBPF(CouplingFlow):
+    """Implementation of Bernstein Polynomial Flows using a coupling transform.
+
+    Supports use of a uniform distribution for the latent space, so far only. This
+    automatically disables the tails and sets the bounds to [0, 1).
+
+    Parameters
+    ----------
+    n_inputs : int
+        Number of inputs
+    n_transforms : int
+        Number of transforms
+    n_conditional_inputs: int
+        Number of conditionals inputs
+    n_neurons : int
+        Number of neurons per residual block in each transform 
+    n_blocks_per_transform : int
+        Number of residual blocks per transform 
+    batch_norm_within_blocks : bool
+        Enable batch normalisation within each residual block
+    batch_norm_between_transforms : bool
+        Enable batch norm between transforms
+    activation : function
+        Activation function to use. Defaults to ReLU
+    dropout_probability : float
+        Amount of dropout to apply. 0 being no dropout and 1 being drop
+        all connections
+    linear_transform : str, {'permutation', 'lu', 'svd', None}
+        Not implemented. Linear transform to apply before each coupling transform.
+    distribution : :obj:`nflows.distribution.Distribution`
+        Distribution object to use for that latent space. Default is multivariate uniform. 
+    mask : Union[torch.Tensor, list, numpy.ndarray]
+        Mask or array of masks to use to construct the flow. If not specified,
+        an alternating binary mask will be used.
+    bernstein_degree : int
+        Degree of Bernstein polynomial transform in each dimension.
+    tail_type : {None, 'linear'}
+        Not implemented. Type of tails to use outside the bounds on which the bernstein polynomials are
+        defined.
+    tail_bound : float
+        Not implemented. Bound that defines the region over which the polynomials are defined.
+        I.e. [-tail_bound, tail_bound]
+    kwargs :
+        Keyword arguments passed to the transform when is it initialised.
+    """
+
+    def __init__(
+        self,
+        n_inputs,
+        n_transforms,
+        n_conditional_inputs=None,
+        n_neurons=32,
+        n_blocks_per_transform=2,
+        batch_norm_within_blocks=False,
+        batch_norm_between_transforms=False,
+        activation=F.relu,
+        dropout_probability=0.0,
+        linear_transform=None,
+        distribution="uniform",
+        mask = None,
+        bernstein_degree=10,
+        log = False,
+        tail_type=None,
+        tail_bound=1.0,
+        **kwargs,
+    ):
+        
+        transform_class = PiecewiseBernsteinCouplingTransform
+
+        if distribution == "uniform":
+            from ..distributions import MultivariateUniform
+
+            tail_bound = 1.0
+            tail_type = None
+            distribution = MultivariateUniform(
+                low=torch.Tensor(n_inputs * [0.0]),
+                high=torch.Tensor(n_inputs * [1.0]),
+            )
+            batch_norm_between_transforms = False
+
+        else:
+            raise NotImplementedError()
+
+        super().__init__(
+            transform_class,
+            n_inputs,
+            n_transforms,
+            n_conditional_inputs=n_conditional_inputs,
+            n_neurons=n_neurons,
+            n_blocks_per_transform=n_blocks_per_transform,
+            batch_norm_within_blocks=batch_norm_within_blocks,
+            batch_norm_between_transforms=batch_norm_between_transforms,
+            activation=activation,
+            dropout_probability=dropout_probability,
+            linear_transform=linear_transform,
+            distribution=distribution,
+            mask=mask,
+            bernstein_degree=bernstein_degree,
+            log = log,
+            tails=tail_type,
+            tail_bound=tail_bound,
+            **kwargs,
+        )
+
+
+#todo: initialise to identity transform..
\ No newline at end of file
diff --git a/src/glasflow/transforms/bernstein.py b/src/glasflow/transforms/bernstein.py
new file mode 100644
index 0000000..5c1ba84
--- /dev/null
+++ b/src/glasflow/transforms/bernstein.py
@@ -0,0 +1,248 @@
+import torch
+from torch.nn import functional as F
+
+from glasflow.nflows.transforms.base import InputOutsideDomain
+
+
+clip = 1e-7
+
+def bernstein_basis_polynomial(k, n):
+    # returns a berstein basis polynomial b_{k,n}(x) = nCk x^k (1-x)^(n-k), nCk = n!/(k!(n-k)!), as a function
+    # gamma(n) = (n-1)!
+    binomial_coeff = torch.exp(
+        torch.special.gammaln(n + 1)
+        - (torch.special.gammaln(n - k + 1) + torch.special.gammaln(k + 1))
+    )
+
+    def basis_polynomial(x):
+        return binomial_coeff * torch.exp(k * torch.log(x) + (n - k) * torch.log(1 - x))
+
+    return basis_polynomial
+
+def log_bernstein_basis_polynomial(k, n):
+    # returns a berstein basis polynomial b_{k,n}(x) = nCk x^k (1-x)^(n-k), nCk = n!/(k!(n-k)!), as a function
+    # gamma(n) = (n-1)!
+    log_binomial_coeff = torch.special.gammaln(n + 1) - (torch.special.gammaln(n - k + 1) + torch.special.gammaln(k + 1))
+
+    def log_basis_polynomial(x):
+        return log_binomial_coeff + k * torch.log1p(x-1) + (n - k) * torch.log1p(- x)
+
+    return log_basis_polynomial
+
+def bernstein_basis_polynomial_derivative(k, n):
+    def db_k_n_dx(x):
+        if k != 0:
+            return n * (
+                bernstein_basis_polynomial(k - 1, n - 1)(x)
+                - bernstein_basis_polynomial(k, n - 1)(x)
+            )
+        else:
+            return -n * torch.exp((n - 1) * torch.log(1 - x))
+
+    return db_k_n_dx
+
+def bernstein_transform_log_derivative(x, alphas):
+    n = alphas.shape[-1] - 1  # degree of the bernstein polynomial
+
+    #alphas[1:]  # alpha_1, alpha_2, ..., alpha_n
+    #alphas[:-1] # alpha_0, alpha_1, ..., alpha_n-1
+
+    log_bernstein_basis = [log_bernstein_basis_polynomial(torch.tensor(k), torch.tensor(n-1)) for k in range(n)]
+    log_bernstein_basis_at_x = torch.stack([log_basis_polynomial(x) for log_basis_polynomial in log_bernstein_basis])
+    coeffs = n*(alphas[:,1:] - alphas[:,:-1])      #(alpha_k - alpha_k-1) for k between 0 and n
+    logdet = torch.logsumexp(log_bernstein_basis_at_x + torch.log(coeffs.T), dim = 0)
+
+    return logdet
+
+def get_increasing_alphas_nd(unconstrained_params, range_min=0, range_max=1):
+    # returns a strictly increasing sequence of alphas, alpha_0=range_min, alpha_n = range_max, n=len(unconstrained_params)
+
+    unconstrained_params = torch.atleast_2d(unconstrained_params)
+    cumsum = torch.cumsum(torch.abs(unconstrained_params) + 1e-5, axis=-1)
+    scaled_params = range_min + cumsum / torch.atleast_2d(cumsum[:, -1]).T * (
+        range_max - range_min
+    )
+    alphas = torch.concatenate(
+        [torch.full((unconstrained_params.shape[0], 1), range_min), scaled_params],
+        axis=-1,
+    )
+
+    return alphas
+
+def bernstein_fwd(x, alphas):
+    """Computes y = f(x)."""
+    # takes x as 1D array of the shape (n_samps), alpha of the shape (n_samps, n_params)
+
+    clip = 1e-6
+    x = torch.clip(x, clip, 1.0 - clip)
+
+    n = alphas.shape[-1] - 1  # degree of the bernstein polynomial
+    bernstein_basis = [bernstein_basis_polynomial(torch.tensor(k), torch.tensor(n)) for k in range(n + 1)]
+    basis_at_x = torch.stack([basis_polynomial(x) for basis_polynomial in bernstein_basis])
+
+    y = torch.sum(torch.multiply(basis_at_x, alphas.T), axis = 0)
+
+    return y
+
+def bernstein_fwd_log(x, alphas):
+    """Computes y = f(x) and log|d/dx(f(x))|"""
+    # takes in a scalar x
+
+    n = alphas.shape[-1] - 1  # degree of the bernstein polynomial
+    log_basis_at_x = torch.stack([log_bernstein_basis_polynomial(torch.tensor(k), torch.tensor(n))(x) for k in range(n + 1)])
+    #log_basis_at_x = torch.stack([log_basis_polynomial(x) for log_basis_polynomial in log_bernstein_basis])
+    
+    y = torch.exp(torch.logsumexp(log_basis_at_x + torch.log(alphas.T), dim = 0))
+
+    return y
+
+def bernstein_log_det(x, alphas):
+    # takes x as 1D array of the shape (n_samps), alpha of the shape (n_samps, n_params)
+
+    n = alphas.shape[-1] - 1  # degree of the bernstein polynomial
+    bernstein_basis_derivatives = [
+        bernstein_basis_polynomial_derivative(torch.tensor(k), torch.tensor(n)) for k in range(n + 1)
+]
+
+    basis_derivative_at_x = torch.stack(
+        [basis_derivative(x) for basis_derivative in bernstein_basis_derivatives]
+    )  # (poly_degree,)
+
+    derivative_in_basis = torch.sum(torch.multiply(basis_derivative_at_x, alphas.T), axis = 0)
+
+    logdet = torch.log(
+        torch.abs(derivative_in_basis)
+    )  # log of the abosolute value of the derivative
+
+    return logdet
+
+
+def bernstein_transform_fwd(x, alphas):
+    """Computes y = f(x) and log|d/dx(f(x))|"""
+    # takes in a scalar x and alphas 1D array
+    x = torch.clip(x, clip,1-clip)
+    y = bernstein_fwd(x, alphas)
+    logabsdet = bernstein_log_det(x, alphas)
+
+    return y, logabsdet
+
+
+def bernstein_transform_fwd_log(x, alphas):
+    """Computes y = f(x) and log|d/dx(f(x))|"""
+    # takes in a scalar x and alphas 1D array
+    x = torch.clip(x, clip,1-clip)
+    y = bernstein_fwd_log(x, alphas)
+    logabsdet = bernstein_transform_log_derivative(x, alphas)
+
+    return y, logabsdet
+
+def bernstein_transform_inv(y, alphas):
+    """Computes x = f^{-1}(y) and  log|d/dy(f^-1(y))|."""
+    n_points = 200
+    n_samps = y.shape[0]
+
+    x_fit = torch.tile(torch.linspace(clip, 1 - clip, n_points), (n_samps, 1))
+
+    alphas_long = torch.tile(alphas, (n_points, 1, 1)) #the same alpha for every sample 
+
+    y_fit = bernstein_fwd(x_fit, alphas_long)
+
+    # interpolation function
+    def inp(y, y_fit, x_fit):
+        return interp(y, y_fit, x_fit)
+
+    x = inp(torch.atleast_2d(y).T, y_fit, x_fit).flatten()
+
+    logdet = -bernstein_log_det(x, alphas)
+
+    return x, logdet
+
+def bernstein_transform_inv_log(y, alphas):
+    """Computes x = f^{-1}(y) and  log|d/dy(f^-1(y))|."""
+    n_points = 200
+    n_samps = y.shape[0]
+
+    x_fit = torch.tile(torch.linspace(clip, 1 - clip, n_points), (n_samps, 1))
+
+    alphas_long = torch.tile(alphas, (n_points, 1, 1)) #the same alpha for every sample 
+
+    y_fit = bernstein_fwd_log(x_fit, alphas_long)
+
+    # interpolation function
+    def inp(y, y_fit, x_fit):
+        return interp(y, y_fit, x_fit)
+
+    x = inp(torch.atleast_2d(y).T, y_fit, x_fit).flatten()
+
+    logdet = -bernstein_transform_log_derivative(x, alphas)
+
+    return x, logdet
+
+
+def interp(x, xp, fp):
+
+    m = torch.diff(fp) / torch.diff(xp) # slope
+    b = fp[..., :-1] - m * xp[..., :-1] # offset
+    indices = torch.searchsorted(xp, x, right=False)
+
+    # constant extrapolation
+    m = torch.cat([torch.zeros_like(m)[..., :1], m, torch.zeros_like(m)[..., :1]], dim=-1)
+    b = torch.cat([fp[..., :1], b, fp[..., -1:]], dim=-1)
+    
+    values = m.gather(-1, indices) * x + b.gather(-1, indices)
+    
+    return values
+
+def bernstein_transform(
+    inputs,
+    unconstrained_alphas,
+    inverse=False,
+    left=0.0,
+    right=1.0,
+    top=0.0,
+    bottom=1.0,
+    log = False
+    ):
+
+    domain_min = left
+    domain_max = right
+    range_min = bottom
+    range_max = top
+    
+
+    #print(inputs.shape)
+    #print(unconstrained_alphas.shape) 
+    
+    initial_shape = inputs.shape
+    inputs = inputs.flatten()
+
+    #unconstrained_alphas = unconstrained_alphas.reshape((unconstrained_alphas.shape[0], unconstrained_alphas.shape[-1]))
+    unconstrained_alphas = unconstrained_alphas.reshape((inputs.shape[0], unconstrained_alphas.shape[-1]))
+    
+    #initial_shape = inputs.shape
+    #inputs = inputs.flatten()
+
+    #check if input is in the domain
+    if torch.min(inputs) < domain_min or torch.max(inputs) > domain_max:
+        raise InputOutsideDomain()
+    
+    #constrain alphas to an increasing sequence
+    alphas = get_increasing_alphas_nd(unconstrained_alphas, range_min=0, range_max=1)
+
+    if log:
+        if inverse:
+            outputs, logabsdet = bernstein_transform_inv_log(inputs, alphas)
+            return outputs.reshape(initial_shape), logabsdet.reshape(initial_shape)
+        
+        else:
+            outputs, logabsdet = bernstein_transform_fwd_log(inputs, alphas)
+            return outputs.reshape(initial_shape), logabsdet.reshape(initial_shape)
+
+    else:
+        if inverse:
+            outputs, logabsdet = bernstein_transform_inv(inputs, alphas)
+            return outputs.reshape(initial_shape), logabsdet.reshape(initial_shape)
+        
+        else:
+            outputs, logabsdet = bernstein_transform_fwd(inputs, alphas)
+            return outputs.reshape(initial_shape), logabsdet.reshape(initial_shape)

From 73c79aacf8a105a635caf64f2757327934cc5a9e Mon Sep 17 00:00:00 2001
From: Dominika Zieba <2316440z@student.gla.ac.uk>
Date: Fri, 21 Mar 2025 14:12:28 +0000
Subject: [PATCH 2/7] Added bernstein flow example

---
 examples/bernstein_example.ipynb | 215 +++++++++++++++++++++++++++++++
 1 file changed, 215 insertions(+)
 create mode 100644 examples/bernstein_example.ipynb

diff --git a/examples/bernstein_example.ipynb b/examples/bernstein_example.ipynb
new file mode 100644
index 0000000..33e61f7
--- /dev/null
+++ b/examples/bernstein_example.ipynb
@@ -0,0 +1,215 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Example of training a flow using `glasflow`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import seaborn as sns\n",
+    "import torch\n",
+    "from torch import optim\n",
+    "import corner\n",
+    "\n",
+    "# Update the plotting style\n",
+    "sns.set_context(\"notebook\")\n",
+    "sns.set_palette(\"colorblind\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Target distribution. \n",
+    "Here this is an unconditional 3D Gaussian with random covariance matrix. So far the Bernstein flow requires the target to be defined on the [0,1]^N hypercube, so when sampling from this Gaussian we will set the prior to be 0 outside of this domain (i.e. clip the samples to the [0,1] interval."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 760x760 with 9 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "A = (0.5 - np.random.uniform(size=(3,3)))/10\n",
+    "C = np.matmul(A.T,A)\n",
+    "target_samples = np.random.multivariate_normal(mean=[0.5,0.5,0.5], cov=C, size=1000)\n",
+    "corner.corner(target_samples)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Prepare the flow\n",
+    "Bernstein degree is the polynomial degree of the bernstein transform. If log = True, then the transform calculations will be performed in log space, which should be numerically more stable (although possibly slower)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from glasflow.flows.bpf import CouplingBPF\n",
+    "\n",
+    "flow = CouplingBPF(n_inputs=3,\n",
+    "    n_transforms=5,\n",
+    "    n_neurons=32,\n",
+    "    batch_norm_between_transforms=True,\n",
+    "    bernstein_degree=30,\n",
+    "    distribution='uniform',\n",
+    "    log = True\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimizer = optim.Adam(flow.parameters())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Train the flow"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "num_iter = 500\n",
+    "train_loss = []\n",
+    "\n",
+    "for i in range(num_iter):\n",
+    "    t_loss = 0\n",
+    "\n",
+    "    x = np.clip(np.random.multivariate_normal(mean=[0.5,0.5,0.5], cov=C, size=1000),0,1)\n",
+    "    x = torch.tensor(x, dtype=torch.float32)\n",
+    "    optimizer.zero_grad()\n",
+    "    loss = -flow.log_prob(inputs=x).mean()\n",
+    "    loss.backward()\n",
+    "    optimizer.step()\n",
+    "    t_loss += loss.item()\n",
+    "    train_loss.append(t_loss)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(train_loss)\n",
+    "plt.xlabel(\"Iteration\", fontsize=12)\n",
+    "plt.ylabel(\"Training loss\", fontsize=12)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Drawing samples from the flow\n",
+    "\n",
+    "We can now draw samples from the trained flow and compare them to the target sample."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n = 1000\n",
+    "flow.eval()\n",
+    "with torch.no_grad():\n",
+    "    generated_samples = flow.sample(1000).numpy()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 760x760 with 9 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "target_samples = np.random.multivariate_normal(mean=[0.5,0.5,0.5], cov=C, size=1000)\n",
+    "range = [[0.3,0.7],[0.3,0.7],[0.3,0.7]]\n",
+    "fig = corner.corner(target_samples, color= 'green', range = range)\n",
+    "corner.corner(generated_samples, fig = fig, weights=np.ones(len(target_samples))*len(generated_samples)/len(target_samples), range = range)\n",
+    "\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "torch",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

From 80155167c51e56f4ef058ab529941b84f21c4cd4 Mon Sep 17 00:00:00 2001
From: Dominika Zieba <2316440z@student.gla.ac.uk>
Date: Mon, 24 Mar 2025 12:58:57 +0000
Subject: [PATCH 3/7] reformatted with black

---
 src/glasflow/flows/bpf.py            |  33 +++---
 src/glasflow/transforms/bernstein.py | 171 +++++++++++++++++++--------
 2 files changed, 136 insertions(+), 68 deletions(-)

diff --git a/src/glasflow/flows/bpf.py b/src/glasflow/flows/bpf.py
index a01184b..34e6427 100644
--- a/src/glasflow/flows/bpf.py
+++ b/src/glasflow/flows/bpf.py
@@ -5,7 +5,7 @@
 See: https://arxiv.org/abs/1906.04032
 """
 
-#from glasflow.nflows.transforms.coupling import PiecewiseBernsteinCouplingTransform
+# from glasflow.nflows.transforms.coupling import PiecewiseBernsteinCouplingTransform
 from glasflow.nflows.transforms.coupling import PiecewiseCouplingTransform
 
 import numpy as np
@@ -15,6 +15,7 @@
 
 from ..transforms.bernstein import bernstein_transform
 
+
 class PiecewiseBernsteinCouplingTransform(PiecewiseCouplingTransform):
     def __init__(
         self,
@@ -24,18 +25,17 @@ def __init__(
         tails=None,
         tail_bound=1.0,
         apply_unconditional_transform=False,
-        log = False
+        log=False,
     ):
 
-        self.bernstein_degree = bernstein_degree 
+        self.bernstein_degree = bernstein_degree
         self.tails = tails
         self.tail_bound = tail_bound
         self.log = log
 
-
         if apply_unconditional_transform:
             raise NotImplementedError()
-        
+
         else:
             unconditional_transform = None
 
@@ -60,16 +60,17 @@ def _piecewise_cdf(self, inputs, transform_params, inverse=False):
                 "Inputs to the softmax are not scaled down: initialization might be bad."
             )
 
-        
         if self.tails is None:
-             bijector_fn = bernstein_transform
+            bijector_fn = bernstein_transform
         else:
             raise NotImplementedError()
 
         return bijector_fn(
             inputs=inputs,
             unconstrained_alphas=unconstrained_alphas,
-            inverse=inverse, log=self.log)
+            inverse=inverse,
+            log=self.log,
+        )
 
 
 class CouplingBPF(CouplingFlow):
@@ -87,9 +88,9 @@ class CouplingBPF(CouplingFlow):
     n_conditional_inputs: int
         Number of conditionals inputs
     n_neurons : int
-        Number of neurons per residual block in each transform 
+        Number of neurons per residual block in each transform
     n_blocks_per_transform : int
-        Number of residual blocks per transform 
+        Number of residual blocks per transform
     batch_norm_within_blocks : bool
         Enable batch normalisation within each residual block
     batch_norm_between_transforms : bool
@@ -102,7 +103,7 @@ class CouplingBPF(CouplingFlow):
     linear_transform : str, {'permutation', 'lu', 'svd', None}
         Not implemented. Linear transform to apply before each coupling transform.
     distribution : :obj:`nflows.distribution.Distribution`
-        Distribution object to use for that latent space. Default is multivariate uniform. 
+        Distribution object to use for that latent space. Default is multivariate uniform.
     mask : Union[torch.Tensor, list, numpy.ndarray]
         Mask or array of masks to use to construct the flow. If not specified,
         an alternating binary mask will be used.
@@ -131,14 +132,14 @@ def __init__(
         dropout_probability=0.0,
         linear_transform=None,
         distribution="uniform",
-        mask = None,
+        mask=None,
         bernstein_degree=10,
-        log = False,
+        log=False,
         tail_type=None,
         tail_bound=1.0,
         **kwargs,
     ):
-        
+
         transform_class = PiecewiseBernsteinCouplingTransform
 
         if distribution == "uniform":
@@ -170,11 +171,11 @@ def __init__(
             distribution=distribution,
             mask=mask,
             bernstein_degree=bernstein_degree,
-            log = log,
+            log=log,
             tails=tail_type,
             tail_bound=tail_bound,
             **kwargs,
         )
 
 
-#todo: initialise to identity transform..
\ No newline at end of file
+# todo: initialise to identity transform..
diff --git a/src/glasflow/transforms/bernstein.py b/src/glasflow/transforms/bernstein.py
index 5c1ba84..ee673a1 100644
--- a/src/glasflow/transforms/bernstein.py
+++ b/src/glasflow/transforms/bernstein.py
@@ -6,6 +6,7 @@
 
 clip = 1e-7
 
+
 def bernstein_basis_polynomial(k, n):
     # returns a berstein basis polynomial b_{k,n}(x) = nCk x^k (1-x)^(n-k), nCk = n!/(k!(n-k)!), as a function
     # gamma(n) = (n-1)!
@@ -15,20 +16,30 @@ def bernstein_basis_polynomial(k, n):
     )
 
     def basis_polynomial(x):
-        return binomial_coeff * torch.exp(k * torch.log(x) + (n - k) * torch.log(1 - x))
+        return binomial_coeff * torch.exp(
+            k * torch.log(x) + (n - k) * torch.log(1 - x)
+        )
 
     return basis_polynomial
 
+
 def log_bernstein_basis_polynomial(k, n):
     # returns a berstein basis polynomial b_{k,n}(x) = nCk x^k (1-x)^(n-k), nCk = n!/(k!(n-k)!), as a function
     # gamma(n) = (n-1)!
-    log_binomial_coeff = torch.special.gammaln(n + 1) - (torch.special.gammaln(n - k + 1) + torch.special.gammaln(k + 1))
+    log_binomial_coeff = torch.special.gammaln(n + 1) - (
+        torch.special.gammaln(n - k + 1) + torch.special.gammaln(k + 1)
+    )
 
     def log_basis_polynomial(x):
-        return log_binomial_coeff + k * torch.log1p(x-1) + (n - k) * torch.log1p(- x)
+        return (
+            log_binomial_coeff
+            + k * torch.log1p(x - 1)
+            + (n - k) * torch.log1p(-x)
+        )
 
     return log_basis_polynomial
 
+
 def bernstein_basis_polynomial_derivative(k, n):
     def db_k_n_dx(x):
         if k != 0:
@@ -41,19 +52,33 @@ def db_k_n_dx(x):
 
     return db_k_n_dx
 
+
 def bernstein_transform_log_derivative(x, alphas):
     n = alphas.shape[-1] - 1  # degree of the bernstein polynomial
 
-    #alphas[1:]  # alpha_1, alpha_2, ..., alpha_n
-    #alphas[:-1] # alpha_0, alpha_1, ..., alpha_n-1
-
-    log_bernstein_basis = [log_bernstein_basis_polynomial(torch.tensor(k), torch.tensor(n-1)) for k in range(n)]
-    log_bernstein_basis_at_x = torch.stack([log_basis_polynomial(x) for log_basis_polynomial in log_bernstein_basis])
-    coeffs = n*(alphas[:,1:] - alphas[:,:-1])      #(alpha_k - alpha_k-1) for k between 0 and n
-    logdet = torch.logsumexp(log_bernstein_basis_at_x + torch.log(coeffs.T), dim = 0)
+    # alphas[1:]  # alpha_1, alpha_2, ..., alpha_n
+    # alphas[:-1] # alpha_0, alpha_1, ..., alpha_n-1
+
+    log_bernstein_basis = [
+        log_bernstein_basis_polynomial(torch.tensor(k), torch.tensor(n - 1))
+        for k in range(n)
+    ]
+    log_bernstein_basis_at_x = torch.stack(
+        [
+            log_basis_polynomial(x)
+            for log_basis_polynomial in log_bernstein_basis
+        ]
+    )
+    coeffs = n * (
+        alphas[:, 1:] - alphas[:, :-1]
+    )  # (alpha_k - alpha_k-1) for k between 0 and n
+    logdet = torch.logsumexp(
+        log_bernstein_basis_at_x + torch.log(coeffs.T), dim=0
+    )
 
     return logdet
 
+
 def get_increasing_alphas_nd(unconstrained_params, range_min=0, range_max=1):
     # returns a strictly increasing sequence of alphas, alpha_0=range_min, alpha_n = range_max, n=len(unconstrained_params)
 
@@ -63,12 +88,16 @@ def get_increasing_alphas_nd(unconstrained_params, range_min=0, range_max=1):
         range_max - range_min
     )
     alphas = torch.concatenate(
-        [torch.full((unconstrained_params.shape[0], 1), range_min), scaled_params],
+        [
+            torch.full((unconstrained_params.shape[0], 1), range_min),
+            scaled_params,
+        ],
         axis=-1,
     )
 
     return alphas
 
+
 def bernstein_fwd(x, alphas):
     """Computes y = f(x)."""
     # takes x as 1D array of the shape (n_samps), alpha of the shape (n_samps, n_params)
@@ -77,38 +106,56 @@ def bernstein_fwd(x, alphas):
     x = torch.clip(x, clip, 1.0 - clip)
 
     n = alphas.shape[-1] - 1  # degree of the bernstein polynomial
-    bernstein_basis = [bernstein_basis_polynomial(torch.tensor(k), torch.tensor(n)) for k in range(n + 1)]
-    basis_at_x = torch.stack([basis_polynomial(x) for basis_polynomial in bernstein_basis])
+    bernstein_basis = [
+        bernstein_basis_polynomial(torch.tensor(k), torch.tensor(n))
+        for k in range(n + 1)
+    ]
+    basis_at_x = torch.stack(
+        [basis_polynomial(x) for basis_polynomial in bernstein_basis]
+    )
 
-    y = torch.sum(torch.multiply(basis_at_x, alphas.T), axis = 0)
+    y = torch.sum(torch.multiply(basis_at_x, alphas.T), axis=0)
 
     return y
 
+
 def bernstein_fwd_log(x, alphas):
     """Computes y = f(x) and log|d/dx(f(x))|"""
     # takes in a scalar x
 
     n = alphas.shape[-1] - 1  # degree of the bernstein polynomial
-    log_basis_at_x = torch.stack([log_bernstein_basis_polynomial(torch.tensor(k), torch.tensor(n))(x) for k in range(n + 1)])
-    #log_basis_at_x = torch.stack([log_basis_polynomial(x) for log_basis_polynomial in log_bernstein_basis])
-    
-    y = torch.exp(torch.logsumexp(log_basis_at_x + torch.log(alphas.T), dim = 0))
+    log_basis_at_x = torch.stack(
+        [
+            log_bernstein_basis_polynomial(torch.tensor(k), torch.tensor(n))(x)
+            for k in range(n + 1)
+        ]
+    )
+    # log_basis_at_x = torch.stack([log_basis_polynomial(x) for log_basis_polynomial in log_bernstein_basis])
+
+    y = torch.exp(torch.logsumexp(log_basis_at_x + torch.log(alphas.T), dim=0))
 
     return y
 
+
 def bernstein_log_det(x, alphas):
     # takes x as 1D array of the shape (n_samps), alpha of the shape (n_samps, n_params)
 
     n = alphas.shape[-1] - 1  # degree of the bernstein polynomial
     bernstein_basis_derivatives = [
-        bernstein_basis_polynomial_derivative(torch.tensor(k), torch.tensor(n)) for k in range(n + 1)
-]
+        bernstein_basis_polynomial_derivative(torch.tensor(k), torch.tensor(n))
+        for k in range(n + 1)
+    ]
 
     basis_derivative_at_x = torch.stack(
-        [basis_derivative(x) for basis_derivative in bernstein_basis_derivatives]
+        [
+            basis_derivative(x)
+            for basis_derivative in bernstein_basis_derivatives
+        ]
     )  # (poly_degree,)
 
-    derivative_in_basis = torch.sum(torch.multiply(basis_derivative_at_x, alphas.T), axis = 0)
+    derivative_in_basis = torch.sum(
+        torch.multiply(basis_derivative_at_x, alphas.T), axis=0
+    )
 
     logdet = torch.log(
         torch.abs(derivative_in_basis)
@@ -120,7 +167,7 @@ def bernstein_log_det(x, alphas):
 def bernstein_transform_fwd(x, alphas):
     """Computes y = f(x) and log|d/dx(f(x))|"""
     # takes in a scalar x and alphas 1D array
-    x = torch.clip(x, clip,1-clip)
+    x = torch.clip(x, clip, 1 - clip)
     y = bernstein_fwd(x, alphas)
     logabsdet = bernstein_log_det(x, alphas)
 
@@ -130,12 +177,13 @@ def bernstein_transform_fwd(x, alphas):
 def bernstein_transform_fwd_log(x, alphas):
     """Computes y = f(x) and log|d/dx(f(x))|"""
     # takes in a scalar x and alphas 1D array
-    x = torch.clip(x, clip,1-clip)
+    x = torch.clip(x, clip, 1 - clip)
     y = bernstein_fwd_log(x, alphas)
     logabsdet = bernstein_transform_log_derivative(x, alphas)
 
     return y, logabsdet
 
+
 def bernstein_transform_inv(y, alphas):
     """Computes x = f^{-1}(y) and  log|d/dy(f^-1(y))|."""
     n_points = 200
@@ -143,7 +191,9 @@ def bernstein_transform_inv(y, alphas):
 
     x_fit = torch.tile(torch.linspace(clip, 1 - clip, n_points), (n_samps, 1))
 
-    alphas_long = torch.tile(alphas, (n_points, 1, 1)) #the same alpha for every sample 
+    alphas_long = torch.tile(
+        alphas, (n_points, 1, 1)
+    )  # the same alpha for every sample
 
     y_fit = bernstein_fwd(x_fit, alphas_long)
 
@@ -157,6 +207,7 @@ def inp(y, y_fit, x_fit):
 
     return x, logdet
 
+
 def bernstein_transform_inv_log(y, alphas):
     """Computes x = f^{-1}(y) and  log|d/dy(f^-1(y))|."""
     n_points = 200
@@ -164,7 +215,9 @@ def bernstein_transform_inv_log(y, alphas):
 
     x_fit = torch.tile(torch.linspace(clip, 1 - clip, n_points), (n_samps, 1))
 
-    alphas_long = torch.tile(alphas, (n_points, 1, 1)) #the same alpha for every sample 
+    alphas_long = torch.tile(
+        alphas, (n_points, 1, 1)
+    )  # the same alpha for every sample
 
     y_fit = bernstein_fwd_log(x_fit, alphas_long)
 
@@ -181,18 +234,21 @@ def inp(y, y_fit, x_fit):
 
 def interp(x, xp, fp):
 
-    m = torch.diff(fp) / torch.diff(xp) # slope
-    b = fp[..., :-1] - m * xp[..., :-1] # offset
+    m = torch.diff(fp) / torch.diff(xp)  # slope
+    b = fp[..., :-1] - m * xp[..., :-1]  # offset
     indices = torch.searchsorted(xp, x, right=False)
 
     # constant extrapolation
-    m = torch.cat([torch.zeros_like(m)[..., :1], m, torch.zeros_like(m)[..., :1]], dim=-1)
+    m = torch.cat(
+        [torch.zeros_like(m)[..., :1], m, torch.zeros_like(m)[..., :1]], dim=-1
+    )
     b = torch.cat([fp[..., :1], b, fp[..., -1:]], dim=-1)
-    
+
     values = m.gather(-1, indices) * x + b.gather(-1, indices)
-    
+
     return values
 
+
 def bernstein_transform(
     inputs,
     unconstrained_alphas,
@@ -201,48 +257,59 @@ def bernstein_transform(
     right=1.0,
     top=0.0,
     bottom=1.0,
-    log = False
-    ):
+    log=False,
+):
 
     domain_min = left
     domain_max = right
     range_min = bottom
     range_max = top
-    
 
-    #print(inputs.shape)
-    #print(unconstrained_alphas.shape) 
-    
+    # print(inputs.shape)
+    # print(unconstrained_alphas.shape)
+
     initial_shape = inputs.shape
     inputs = inputs.flatten()
 
-    #unconstrained_alphas = unconstrained_alphas.reshape((unconstrained_alphas.shape[0], unconstrained_alphas.shape[-1]))
-    unconstrained_alphas = unconstrained_alphas.reshape((inputs.shape[0], unconstrained_alphas.shape[-1]))
-    
-    #initial_shape = inputs.shape
-    #inputs = inputs.flatten()
+    # unconstrained_alphas = unconstrained_alphas.reshape((unconstrained_alphas.shape[0], unconstrained_alphas.shape[-1]))
+    unconstrained_alphas = unconstrained_alphas.reshape(
+        (inputs.shape[0], unconstrained_alphas.shape[-1])
+    )
+
+    # initial_shape = inputs.shape
+    # inputs = inputs.flatten()
 
-    #check if input is in the domain
+    # check if input is in the domain
     if torch.min(inputs) < domain_min or torch.max(inputs) > domain_max:
         raise InputOutsideDomain()
-    
-    #constrain alphas to an increasing sequence
-    alphas = get_increasing_alphas_nd(unconstrained_alphas, range_min=0, range_max=1)
+
+    # constrain alphas to an increasing sequence
+    alphas = get_increasing_alphas_nd(
+        unconstrained_alphas, range_min=0, range_max=1
+    )
 
     if log:
         if inverse:
             outputs, logabsdet = bernstein_transform_inv_log(inputs, alphas)
-            return outputs.reshape(initial_shape), logabsdet.reshape(initial_shape)
-        
+            return outputs.reshape(initial_shape), logabsdet.reshape(
+                initial_shape
+            )
+
         else:
             outputs, logabsdet = bernstein_transform_fwd_log(inputs, alphas)
-            return outputs.reshape(initial_shape), logabsdet.reshape(initial_shape)
+            return outputs.reshape(initial_shape), logabsdet.reshape(
+                initial_shape
+            )
 
     else:
         if inverse:
             outputs, logabsdet = bernstein_transform_inv(inputs, alphas)
-            return outputs.reshape(initial_shape), logabsdet.reshape(initial_shape)
-        
+            return outputs.reshape(initial_shape), logabsdet.reshape(
+                initial_shape
+            )
+
         else:
             outputs, logabsdet = bernstein_transform_fwd(inputs, alphas)
-            return outputs.reshape(initial_shape), logabsdet.reshape(initial_shape)
+            return outputs.reshape(initial_shape), logabsdet.reshape(
+                initial_shape
+            )

From 9132c24def095d590b21d1aa226eaf282924f925 Mon Sep 17 00:00:00 2001
From: Dominika Zieba <2316440z@student.gla.ac.uk>
Date: Mon, 24 Mar 2025 13:12:09 +0000
Subject: [PATCH 4/7] reformatted example notebook

---
 examples/bernstein_example.ipynb | 38 +++++++++++++++++++++++---------
 1 file changed, 27 insertions(+), 11 deletions(-)

diff --git a/examples/bernstein_example.ipynb b/examples/bernstein_example.ipynb
index 33e61f7..6fb5314 100644
--- a/examples/bernstein_example.ipynb
+++ b/examples/bernstein_example.ipynb
@@ -50,9 +50,11 @@
     }
    ],
    "source": [
-    "A = (0.5 - np.random.uniform(size=(3,3)))/10\n",
-    "C = np.matmul(A.T,A)\n",
-    "target_samples = np.random.multivariate_normal(mean=[0.5,0.5,0.5], cov=C, size=1000)\n",
+    "A = (0.5 - np.random.uniform(size=(3, 3))) / 10\n",
+    "C = np.matmul(A.T, A)\n",
+    "target_samples = np.random.multivariate_normal(\n",
+    "    mean=[0.5, 0.5, 0.5], cov=C, size=1000\n",
+    ")\n",
     "corner.corner(target_samples)\n",
     "plt.show()"
    ]
@@ -73,13 +75,14 @@
    "source": [
     "from glasflow.flows.bpf import CouplingBPF\n",
     "\n",
-    "flow = CouplingBPF(n_inputs=3,\n",
+    "flow = CouplingBPF(\n",
+    "    n_inputs=3,\n",
     "    n_transforms=5,\n",
     "    n_neurons=32,\n",
     "    batch_norm_between_transforms=True,\n",
     "    bernstein_degree=30,\n",
-    "    distribution='uniform',\n",
-    "    log = True\n",
+    "    distribution=\"uniform\",\n",
+    "    log=True,\n",
     ")"
    ]
   },
@@ -111,7 +114,11 @@
     "for i in range(num_iter):\n",
     "    t_loss = 0\n",
     "\n",
-    "    x = np.clip(np.random.multivariate_normal(mean=[0.5,0.5,0.5], cov=C, size=1000),0,1)\n",
+    "    x = np.clip(\n",
+    "        np.random.multivariate_normal(mean=[0.5, 0.5, 0.5], cov=C, size=1000),\n",
+    "        0,\n",
+    "        1,\n",
+    "    )\n",
     "    x = torch.tensor(x, dtype=torch.float32)\n",
     "    optimizer.zero_grad()\n",
     "    loss = -flow.log_prob(inputs=x).mean()\n",
@@ -182,10 +189,19 @@
     }
    ],
    "source": [
-    "target_samples = np.random.multivariate_normal(mean=[0.5,0.5,0.5], cov=C, size=1000)\n",
-    "range = [[0.3,0.7],[0.3,0.7],[0.3,0.7]]\n",
-    "fig = corner.corner(target_samples, color= 'green', range = range)\n",
-    "corner.corner(generated_samples, fig = fig, weights=np.ones(len(target_samples))*len(generated_samples)/len(target_samples), range = range)\n",
+    "target_samples = np.random.multivariate_normal(\n",
+    "    mean=[0.5, 0.5, 0.5], cov=C, size=1000\n",
+    ")\n",
+    "range = [[0.3, 0.7], [0.3, 0.7], [0.3, 0.7]]\n",
+    "fig = corner.corner(target_samples, color=\"green\", range=range)\n",
+    "corner.corner(\n",
+    "    generated_samples,\n",
+    "    fig=fig,\n",
+    "    weights=np.ones(len(target_samples))\n",
+    "    * len(generated_samples)\n",
+    "    / len(target_samples),\n",
+    "    range=range,\n",
+    ")\n",
     "\n",
     "plt.show()"
    ]

From da827e5f7ebc7d2be92c6f1b0a05bf7a743a4978 Mon Sep 17 00:00:00 2001
From: Dominika Zieba <2316440z@student.gla.ac.uk>
Date: Wed, 9 Apr 2025 14:54:10 +0100
Subject: [PATCH 5/7] added a uniform latent with a sigmoid-logit transform

---
 src/glasflow/flows/bpf.py            | 20 +++---
 src/glasflow/transforms/bernstein.py | 94 ++++++++++++++++++----------
 2 files changed, 72 insertions(+), 42 deletions(-)

diff --git a/src/glasflow/flows/bpf.py b/src/glasflow/flows/bpf.py
index 34e6427..f6db5ea 100644
--- a/src/glasflow/flows/bpf.py
+++ b/src/glasflow/flows/bpf.py
@@ -25,6 +25,7 @@ def __init__(
         tails=None,
         tail_bound=1.0,
         apply_unconditional_transform=False,
+        base_distribution = 'uniform',
         log=False,
     ):
 
@@ -32,6 +33,7 @@ def __init__(
         self.tails = tails
         self.tail_bound = tail_bound
         self.log = log
+        self.base_distribution = base_distribution
 
         if apply_unconditional_transform:
             raise NotImplementedError()
@@ -46,7 +48,7 @@ def __init__(
         )
 
     def _transform_dim_multiplier(self):
-        return self.bernstein_degree - 1
+        return self.bernstein_degree
 
     def _piecewise_cdf(self, inputs, transform_params, inverse=False):
         unconstrained_alphas = transform_params
@@ -69,6 +71,7 @@ def _piecewise_cdf(self, inputs, transform_params, inverse=False):
             inputs=inputs,
             unconstrained_alphas=unconstrained_alphas,
             inverse=inverse,
+            base_distribution = self.base_distribution,
             log=self.log,
         )
 
@@ -94,7 +97,7 @@ class CouplingBPF(CouplingFlow):
     batch_norm_within_blocks : bool
         Enable batch normalisation within each residual block
     batch_norm_between_transforms : bool
-        Enable batch norm between transforms
+        Enable batch norm between transforms. False for uniform latent space. 
     activation : function
         Activation function to use. Defaults to ReLU
     dropout_probability : float
@@ -103,7 +106,7 @@ class CouplingBPF(CouplingFlow):
     linear_transform : str, {'permutation', 'lu', 'svd', None}
         Not implemented. Linear transform to apply before each coupling transform.
     distribution : :obj:`nflows.distribution.Distribution`
-        Distribution object to use for that latent space. Default is multivariate uniform.
+        Distribution object to use for that latent space. Default is multivariate uniform. Others not implemented yet.
     mask : Union[torch.Tensor, list, numpy.ndarray]
         Mask or array of masks to use to construct the flow. If not specified,
         an alternating binary mask will be used.
@@ -131,7 +134,7 @@ def __init__(
         activation=F.relu,
         dropout_probability=0.0,
         linear_transform=None,
-        distribution="uniform",
+        distribution=None,
         mask=None,
         bernstein_degree=10,
         log=False,
@@ -144,17 +147,17 @@ def __init__(
 
         if distribution == "uniform":
             from ..distributions import MultivariateUniform
-
             tail_bound = 1.0
             tail_type = None
-            distribution = MultivariateUniform(
+            distribution_object = MultivariateUniform(
                 low=torch.Tensor(n_inputs * [0.0]),
                 high=torch.Tensor(n_inputs * [1.0]),
             )
             batch_norm_between_transforms = False
 
         else:
-            raise NotImplementedError()
+            distribution_object = distribution #this is later interpreted as a gaussian
+        #    raise NotImplementedError()
 
         super().__init__(
             transform_class,
@@ -168,10 +171,11 @@ def __init__(
             activation=activation,
             dropout_probability=dropout_probability,
             linear_transform=linear_transform,
-            distribution=distribution,
+            distribution=distribution_object,
             mask=mask,
             bernstein_degree=bernstein_degree,
             log=log,
+            base_distribution = distribution,
             tails=tail_type,
             tail_bound=tail_bound,
             **kwargs,
diff --git a/src/glasflow/transforms/bernstein.py b/src/glasflow/transforms/bernstein.py
index ee673a1..0e46f9e 100644
--- a/src/glasflow/transforms/bernstein.py
+++ b/src/glasflow/transforms/bernstein.py
@@ -248,6 +248,17 @@ def interp(x, xp, fp):
 
     return values
 
+def sigmoid(x):
+    y = 1/(1+torch.exp(-x))
+    log_dy_dx = torch.log(y) + torch.log1p(-y)
+
+    return y, log_dy_dx
+
+def logit(x):
+    y = torch.log(x) - torch.log1p(-x)
+    log_dy_dx =  -(torch.log(x - x**2))
+    return y, log_dy_dx
+
 
 def bernstein_transform(
     inputs,
@@ -255,19 +266,17 @@ def bernstein_transform(
     inverse=False,
     left=0.0,
     right=1.0,
-    top=0.0,
-    bottom=1.0,
+    top=1.0,
+    bottom=0.0,
+    base_distribution = None,
     log=False,
 ):
-
+    
     domain_min = left
     domain_max = right
     range_min = bottom
     range_max = top
 
-    # print(inputs.shape)
-    # print(unconstrained_alphas.shape)
-
     initial_shape = inputs.shape
     inputs = inputs.flatten()
 
@@ -275,41 +284,58 @@ def bernstein_transform(
     unconstrained_alphas = unconstrained_alphas.reshape(
         (inputs.shape[0], unconstrained_alphas.shape[-1])
     )
-
-    # initial_shape = inputs.shape
-    # inputs = inputs.flatten()
-
-    # check if input is in the domain
-    if torch.min(inputs) < domain_min or torch.max(inputs) > domain_max:
-        raise InputOutsideDomain()
-
+    
     # constrain alphas to an increasing sequence
     alphas = get_increasing_alphas_nd(
-        unconstrained_alphas, range_min=0, range_max=1
+        unconstrained_alphas, range_min=range_min, range_max=range_max
     )
 
-    if log:
-        if inverse:
-            outputs, logabsdet = bernstein_transform_inv_log(inputs, alphas)
-            return outputs.reshape(initial_shape), logabsdet.reshape(
-                initial_shape
-            )
+    #print(torch.min(inputs))
+    #print(torch.max(inputs))
+
+    if base_distribution == None: #None = gaussian latent
+        #sigmoid the data fit within the [0,1] domain of the Bernstein transforms 
+        inputs,log_j_1 = sigmoid(inputs)
+    
+        # check if input is in the domain
+        if torch.min(inputs) < domain_min or torch.max(inputs) > domain_max:
+            raise InputOutsideDomain()
+
+        if log:
+            if inverse:
+                outputs, logabsdet = bernstein_transform_inv_log(inputs, alphas)
+            else:
+                outputs, logabsdet = bernstein_transform_fwd_log(inputs, alphas)
 
         else:
-            outputs, logabsdet = bernstein_transform_fwd_log(inputs, alphas)
-            return outputs.reshape(initial_shape), logabsdet.reshape(
-                initial_shape
-            )
+            if inverse:
+                outputs, logabsdet = bernstein_transform_inv(inputs, alphas)
+            else:
+                outputs, logabsdet = bernstein_transform_fwd(inputs, alphas)
+
+        #logit the data (bring back to infinite range)
+        outputs, log_j_2 = logit(outputs)
+        logabsdet = logabsdet+log_j_1+log_j_2
+        #print(log_j_2)
 
     else:
-        if inverse:
-            outputs, logabsdet = bernstein_transform_inv(inputs, alphas)
-            return outputs.reshape(initial_shape), logabsdet.reshape(
-                initial_shape
-            )
+        # check if input is in the domain
+        if torch.min(inputs) < domain_min or torch.max(inputs) > domain_max:
+            raise InputOutsideDomain()
+
+        if log:
+            if inverse:
+                outputs, logabsdet = bernstein_transform_inv_log(inputs, alphas)
+            else:
+                outputs, logabsdet = bernstein_transform_fwd_log(inputs, alphas)
 
         else:
-            outputs, logabsdet = bernstein_transform_fwd(inputs, alphas)
-            return outputs.reshape(initial_shape), logabsdet.reshape(
-                initial_shape
-            )
+            if inverse:
+                outputs, logabsdet = bernstein_transform_inv(inputs, alphas)
+            else:
+                outputs, logabsdet = bernstein_transform_fwd(inputs, alphas)
+
+    return outputs.reshape(initial_shape), logabsdet.reshape(
+                    initial_shape
+                )
+

From 77b2c33e3cf3a835e4eb28c673732ea8493ac8fe Mon Sep 17 00:00:00 2001
From: Dominika Zieba <2316440z@student.gla.ac.uk>
Date: Tue, 22 Apr 2025 11:53:54 +0100
Subject: [PATCH 6/7] removed tail args and fixed clipping at edges

---
 src/glasflow/flows/bpf.py            | 28 ++++----------------
 src/glasflow/transforms/bernstein.py | 39 +++++++++++++++++++++-------
 2 files changed, 34 insertions(+), 33 deletions(-)

diff --git a/src/glasflow/flows/bpf.py b/src/glasflow/flows/bpf.py
index f6db5ea..294b1ad 100644
--- a/src/glasflow/flows/bpf.py
+++ b/src/glasflow/flows/bpf.py
@@ -22,18 +22,13 @@ def __init__(
         mask,
         transform_net_create_fn,
         bernstein_degree=10,
-        tails=None,
-        tail_bound=1.0,
-        apply_unconditional_transform=False,
         base_distribution = 'uniform',
         log=False,
+        apply_unconditional_transform=False,
     ):
 
         self.bernstein_degree = bernstein_degree
-        self.tails = tails
-        self.tail_bound = tail_bound
         self.log = log
-        self.base_distribution = base_distribution
 
         if apply_unconditional_transform:
             raise NotImplementedError()
@@ -47,6 +42,8 @@ def __init__(
             unconditional_transform=unconditional_transform,
         )
 
+        self.base_distribution = base_distribution
+
     def _transform_dim_multiplier(self):
         return self.bernstein_degree
 
@@ -61,11 +58,8 @@ def _piecewise_cdf(self, inputs, transform_params, inverse=False):
             warnings.warn(
                 "Inputs to the softmax are not scaled down: initialization might be bad."
             )
-
-        if self.tails is None:
-            bijector_fn = bernstein_transform
-        else:
-            raise NotImplementedError()
+    
+        bijector_fn = bernstein_transform
 
         return bijector_fn(
             inputs=inputs,
@@ -112,12 +106,6 @@ class CouplingBPF(CouplingFlow):
         an alternating binary mask will be used.
     bernstein_degree : int
         Degree of Bernstein polynomial transform in each dimension.
-    tail_type : {None, 'linear'}
-        Not implemented. Type of tails to use outside the bounds on which the bernstein polynomials are
-        defined.
-    tail_bound : float
-        Not implemented. Bound that defines the region over which the polynomials are defined.
-        I.e. [-tail_bound, tail_bound]
     kwargs :
         Keyword arguments passed to the transform when is it initialised.
     """
@@ -138,8 +126,6 @@ def __init__(
         mask=None,
         bernstein_degree=10,
         log=False,
-        tail_type=None,
-        tail_bound=1.0,
         **kwargs,
     ):
 
@@ -147,8 +133,6 @@ def __init__(
 
         if distribution == "uniform":
             from ..distributions import MultivariateUniform
-            tail_bound = 1.0
-            tail_type = None
             distribution_object = MultivariateUniform(
                 low=torch.Tensor(n_inputs * [0.0]),
                 high=torch.Tensor(n_inputs * [1.0]),
@@ -176,8 +160,6 @@ def __init__(
             bernstein_degree=bernstein_degree,
             log=log,
             base_distribution = distribution,
-            tails=tail_type,
-            tail_bound=tail_bound,
             **kwargs,
         )
 
diff --git a/src/glasflow/transforms/bernstein.py b/src/glasflow/transforms/bernstein.py
index 0e46f9e..378dbd9 100644
--- a/src/glasflow/transforms/bernstein.py
+++ b/src/glasflow/transforms/bernstein.py
@@ -4,7 +4,7 @@
 from glasflow.nflows.transforms.base import InputOutsideDomain
 
 
-clip = 1e-7
+clip = 0.
 
 
 def bernstein_basis_polynomial(k, n):
@@ -16,9 +16,21 @@ def bernstein_basis_polynomial(k, n):
     )
 
     def basis_polynomial(x):
-        return binomial_coeff * torch.exp(
-            k * torch.log(x) + (n - k) * torch.log(1 - x)
-        )
+        if k == 0:
+            return torch.where(x==0, torch.tensor(1.), binomial_coeff * torch.exp(
+                k * torch.log(x) + (n - k) * torch.log(1 - x)))
+        if k == n:
+            return torch.where(x==1, torch.tensor(1.), binomial_coeff * torch.exp(
+                k * torch.log(x) + (n - k) * torch.log(1 - x)))
+        else:
+            return binomial_coeff * torch.exp(
+                k * torch.log(x) + (n - k) * torch.log(1 - x)
+            )
+        
+    #def basis_polynomial(x):
+    #    return binomial_coeff * torch.exp(
+    #            k * torch.log(x) + (n - k) * torch.log(1 - x)
+    #        )
 
     return basis_polynomial
 
@@ -31,11 +43,19 @@ def log_bernstein_basis_polynomial(k, n):
     )
 
     def log_basis_polynomial(x):
-        return (
-            log_binomial_coeff
-            + k * torch.log1p(x - 1)
-            + (n - k) * torch.log1p(-x)
-        )
+        if k == 0:
+            return torch.where(x==0, torch.tensor(0.), log_binomial_coeff + k * torch.log1p(x - 1) + (n - k) * torch.log1p(-x))
+        if k == n:
+            return torch.where(x==1, torch.tensor(0.), log_binomial_coeff + k * torch.log1p(x - 1) + (n - k) * torch.log1p(-x))
+        else:
+            return log_binomial_coeff + k * torch.log1p(x - 1) + (n - k) * torch.log1p(-x)
+        
+    #def log_basis_polynomial(x):
+    #    return (
+    #        log_binomial_coeff
+    #        + k * torch.log1p(x - 1)
+    #        + (n - k) * torch.log1p(-x)
+    #    )
 
     return log_basis_polynomial
 
@@ -102,7 +122,6 @@ def bernstein_fwd(x, alphas):
     """Computes y = f(x)."""
     # takes x as 1D array of the shape (n_samps), alpha of the shape (n_samps, n_params)
 
-    clip = 1e-6
     x = torch.clip(x, clip, 1.0 - clip)
 
     n = alphas.shape[-1] - 1  # degree of the bernstein polynomial

From d2e51aff846d00ee1e8fd22d69cba29d9308be5f Mon Sep 17 00:00:00 2001
From: Dominika Zieba <2316440z@student.gla.ac.uk>
Date: Tue, 22 Apr 2025 11:57:11 +0100
Subject: [PATCH 7/7] reformatted

---
 src/glasflow/flows/bpf.py            | 15 +++--
 src/glasflow/transforms/bernstein.py | 99 ++++++++++++++++++----------
 2 files changed, 74 insertions(+), 40 deletions(-)

diff --git a/src/glasflow/flows/bpf.py b/src/glasflow/flows/bpf.py
index 294b1ad..9bf5b3c 100644
--- a/src/glasflow/flows/bpf.py
+++ b/src/glasflow/flows/bpf.py
@@ -22,7 +22,7 @@ def __init__(
         mask,
         transform_net_create_fn,
         bernstein_degree=10,
-        base_distribution = 'uniform',
+        base_distribution="uniform",
         log=False,
         apply_unconditional_transform=False,
     ):
@@ -58,14 +58,14 @@ def _piecewise_cdf(self, inputs, transform_params, inverse=False):
             warnings.warn(
                 "Inputs to the softmax are not scaled down: initialization might be bad."
             )
-    
+
         bijector_fn = bernstein_transform
 
         return bijector_fn(
             inputs=inputs,
             unconstrained_alphas=unconstrained_alphas,
             inverse=inverse,
-            base_distribution = self.base_distribution,
+            base_distribution=self.base_distribution,
             log=self.log,
         )
 
@@ -91,7 +91,7 @@ class CouplingBPF(CouplingFlow):
     batch_norm_within_blocks : bool
         Enable batch normalisation within each residual block
     batch_norm_between_transforms : bool
-        Enable batch norm between transforms. False for uniform latent space. 
+        Enable batch norm between transforms. False for uniform latent space.
     activation : function
         Activation function to use. Defaults to ReLU
     dropout_probability : float
@@ -133,6 +133,7 @@ def __init__(
 
         if distribution == "uniform":
             from ..distributions import MultivariateUniform
+
             distribution_object = MultivariateUniform(
                 low=torch.Tensor(n_inputs * [0.0]),
                 high=torch.Tensor(n_inputs * [1.0]),
@@ -140,7 +141,9 @@ def __init__(
             batch_norm_between_transforms = False
 
         else:
-            distribution_object = distribution #this is later interpreted as a gaussian
+            distribution_object = (
+                distribution  # this is later interpreted as a gaussian
+            )
         #    raise NotImplementedError()
 
         super().__init__(
@@ -159,7 +162,7 @@ def __init__(
             mask=mask,
             bernstein_degree=bernstein_degree,
             log=log,
-            base_distribution = distribution,
+            base_distribution=distribution,
             **kwargs,
         )
 
diff --git a/src/glasflow/transforms/bernstein.py b/src/glasflow/transforms/bernstein.py
index 378dbd9..9e6ed84 100644
--- a/src/glasflow/transforms/bernstein.py
+++ b/src/glasflow/transforms/bernstein.py
@@ -4,7 +4,7 @@
 from glasflow.nflows.transforms.base import InputOutsideDomain
 
 
-clip = 0.
+clip = 0.0
 
 
 def bernstein_basis_polynomial(k, n):
@@ -17,17 +17,25 @@ def bernstein_basis_polynomial(k, n):
 
     def basis_polynomial(x):
         if k == 0:
-            return torch.where(x==0, torch.tensor(1.), binomial_coeff * torch.exp(
-                k * torch.log(x) + (n - k) * torch.log(1 - x)))
+            return torch.where(
+                x == 0,
+                torch.tensor(1.0),
+                binomial_coeff
+                * torch.exp(k * torch.log(x) + (n - k) * torch.log(1 - x)),
+            )
         if k == n:
-            return torch.where(x==1, torch.tensor(1.), binomial_coeff * torch.exp(
-                k * torch.log(x) + (n - k) * torch.log(1 - x)))
+            return torch.where(
+                x == 1,
+                torch.tensor(1.0),
+                binomial_coeff
+                * torch.exp(k * torch.log(x) + (n - k) * torch.log(1 - x)),
+            )
         else:
             return binomial_coeff * torch.exp(
                 k * torch.log(x) + (n - k) * torch.log(1 - x)
             )
-        
-    #def basis_polynomial(x):
+
+    # def basis_polynomial(x):
     #    return binomial_coeff * torch.exp(
     #            k * torch.log(x) + (n - k) * torch.log(1 - x)
     #        )
@@ -44,13 +52,29 @@ def log_bernstein_basis_polynomial(k, n):
 
     def log_basis_polynomial(x):
         if k == 0:
-            return torch.where(x==0, torch.tensor(0.), log_binomial_coeff + k * torch.log1p(x - 1) + (n - k) * torch.log1p(-x))
+            return torch.where(
+                x == 0,
+                torch.tensor(0.0),
+                log_binomial_coeff
+                + k * torch.log1p(x - 1)
+                + (n - k) * torch.log1p(-x),
+            )
         if k == n:
-            return torch.where(x==1, torch.tensor(0.), log_binomial_coeff + k * torch.log1p(x - 1) + (n - k) * torch.log1p(-x))
+            return torch.where(
+                x == 1,
+                torch.tensor(0.0),
+                log_binomial_coeff
+                + k * torch.log1p(x - 1)
+                + (n - k) * torch.log1p(-x),
+            )
         else:
-            return log_binomial_coeff + k * torch.log1p(x - 1) + (n - k) * torch.log1p(-x)
-        
-    #def log_basis_polynomial(x):
+            return (
+                log_binomial_coeff
+                + k * torch.log1p(x - 1)
+                + (n - k) * torch.log1p(-x)
+            )
+
+    # def log_basis_polynomial(x):
     #    return (
     #        log_binomial_coeff
     #        + k * torch.log1p(x - 1)
@@ -267,15 +291,17 @@ def interp(x, xp, fp):
 
     return values
 
+
 def sigmoid(x):
-    y = 1/(1+torch.exp(-x))
+    y = 1 / (1 + torch.exp(-x))
     log_dy_dx = torch.log(y) + torch.log1p(-y)
 
     return y, log_dy_dx
 
+
 def logit(x):
     y = torch.log(x) - torch.log1p(-x)
-    log_dy_dx =  -(torch.log(x - x**2))
+    log_dy_dx = -(torch.log(x - x**2))
     return y, log_dy_dx
 
 
@@ -287,10 +313,10 @@ def bernstein_transform(
     right=1.0,
     top=1.0,
     bottom=0.0,
-    base_distribution = None,
+    base_distribution=None,
     log=False,
 ):
-    
+
     domain_min = left
     domain_max = right
     range_min = bottom
@@ -303,28 +329,32 @@ def bernstein_transform(
     unconstrained_alphas = unconstrained_alphas.reshape(
         (inputs.shape[0], unconstrained_alphas.shape[-1])
     )
-    
+
     # constrain alphas to an increasing sequence
     alphas = get_increasing_alphas_nd(
         unconstrained_alphas, range_min=range_min, range_max=range_max
     )
 
-    #print(torch.min(inputs))
-    #print(torch.max(inputs))
+    # print(torch.min(inputs))
+    # print(torch.max(inputs))
+
+    if base_distribution == None:  # None = gaussian latent
+        # sigmoid the data fit within the [0,1] domain of the Bernstein transforms
+        inputs, log_j_1 = sigmoid(inputs)
 
-    if base_distribution == None: #None = gaussian latent
-        #sigmoid the data fit within the [0,1] domain of the Bernstein transforms 
-        inputs,log_j_1 = sigmoid(inputs)
-    
         # check if input is in the domain
         if torch.min(inputs) < domain_min or torch.max(inputs) > domain_max:
             raise InputOutsideDomain()
 
         if log:
             if inverse:
-                outputs, logabsdet = bernstein_transform_inv_log(inputs, alphas)
+                outputs, logabsdet = bernstein_transform_inv_log(
+                    inputs, alphas
+                )
             else:
-                outputs, logabsdet = bernstein_transform_fwd_log(inputs, alphas)
+                outputs, logabsdet = bernstein_transform_fwd_log(
+                    inputs, alphas
+                )
 
         else:
             if inverse:
@@ -332,10 +362,10 @@ def bernstein_transform(
             else:
                 outputs, logabsdet = bernstein_transform_fwd(inputs, alphas)
 
-        #logit the data (bring back to infinite range)
+        # logit the data (bring back to infinite range)
         outputs, log_j_2 = logit(outputs)
-        logabsdet = logabsdet+log_j_1+log_j_2
-        #print(log_j_2)
+        logabsdet = logabsdet + log_j_1 + log_j_2
+        # print(log_j_2)
 
     else:
         # check if input is in the domain
@@ -344,9 +374,13 @@ def bernstein_transform(
 
         if log:
             if inverse:
-                outputs, logabsdet = bernstein_transform_inv_log(inputs, alphas)
+                outputs, logabsdet = bernstein_transform_inv_log(
+                    inputs, alphas
+                )
             else:
-                outputs, logabsdet = bernstein_transform_fwd_log(inputs, alphas)
+                outputs, logabsdet = bernstein_transform_fwd_log(
+                    inputs, alphas
+                )
 
         else:
             if inverse:
@@ -354,7 +388,4 @@ def bernstein_transform(
             else:
                 outputs, logabsdet = bernstein_transform_fwd(inputs, alphas)
 
-    return outputs.reshape(initial_shape), logabsdet.reshape(
-                    initial_shape
-                )
-
+    return outputs.reshape(initial_shape), logabsdet.reshape(initial_shape)