Flowification: Everything is a Normalizing Flow
Abstract
We develop a method that can be used to calculate the likelihood contribution of linear and convolutional layers allowing multi-layer perceptrons and convolutional networks to be converted into normalizing flows. We term this process flowification .
In some cases flowification requires the addition of uncorrelated noise to the model but in the simplest case no additional parameters.
The technique we develop can be applied to a broad range of architectures, allowing them to be used for a wide range of tasks.
Our models also allow existing density estimation techniques to be combined with high performance feature extractors.
In contrast to standard density estimation techniques that require specific architectures and specialized knowledge, our approach can leverage design knowledge from different domains and is a step closer to the realization of general purpose architectures.
We investigate the efficacy of linear and convolutional layers for the task of density estimation on standard datasets.
Introduction
Density estimation techniques have proven effective on a wide variety of downstream tasks such as sample generation and anomaly detection [1–6].
Normalizing flows and autoregressive models perform very well at density estimation but do not easily scale to large dimensions [6–8] and have to satisfy strict design constraints to ensure efficient computation of their Jacobians and inverses.
Advances in other areas of machine learning cannot be utilized as flow architectures because they are not typically seen as being invertible; this restricts the application of highly optimized architectures from many domains to density estimation and the use of the likelihood for diagnosing these architectures.
Methods using standard convolutions and residual layers for density estimation have been developed for architectures with specific properties [9–12].
These methods do not provide a recipe for converting general architectures into flows.
There is no known correspondence between normalizing flows and the operations defined by linear and convolutional layers.
In this paper we show that a large proportion of machine learning models can be trained as normalizing flows.
The forward pass of these models remains unchanged apart from the possible addition of uncorrelated noise.
To demonstrate our formulation works we apply it to fully connected layers, convolutions and residual connections.
The contributions of this paper include:
∗ Equal contribution. • In §3.1 we show that linear layers induce densities as augmented normalizing flows [13] with the multi-scale architecture used in RealNVPs [4].
We also show how these layers can be viewed as funnels [14] to increase their expressivity.
We term this process flowification .
• In §3.2 we argue that most ML architectures can be decomposed into simple building blocks that are easy to flowify.
As an example, we derive the specifics for two dimensional convolutional layers and residual blocks. • In §4 we flowify multi-layer perceptrons and convolutional networks and train them as normalizing flows using the likelihood.
This demonstrates that models built from standard layers can be used for density estimation directly.
Background Normalizing flows
Given a base probability density { p 0 ( z ) | z ∈ Z } and a diffeomorphism f : X → Z , the pullback along f induces a probability density { p ( x ) | x ∈ X } on X , where the likelihood of any x ∈ X is given by p ( x ) = p 0 ( f ( x )) | det ( J fx ) | , where J fx is the Jacobian of f evaluated at x .
Thus, the log-likelihoods of the two densities are related by an additive term, which will be referred to as the likelihood contribution V ( x, z ) [15].
Normalizing flows [1] parametrize a family f θ of invertible functions from X to Z . The parameters θ are then optimized to maximize the likelihood of the training data.
A lot of development has gone into constructing flexible invertible functions with easy to calculate Jacobians where both the forward and inverse passes are fast to compute [4–6, 16, 17].
As the function f must be invertible it is required to preserve the dimension of the data.
This limits the expressivity of f and makes it expensive to model high dimensional data distributions.
To reduce these issues several works have studied dimension altering variants of flows [13, 15, 18–21].
Reducing the dimensionality A simple method for altering the dimension of a flow is to take the output of an intermediate layer z ′ and partition it into two pieces z ′
= { z ′ 1 , z ′ 2 } .
Multiscale architectures [4] match z ′ 2 directly to a base density and apply further transformations z ′ 1 .
Funnels [14] generalize this by allowing z ′ 2 to depend on z ′ 1 , i.e. they work with the model p ( z ′ )
=
p ( f ′ ( z ′ 1 )) p ( z ′ 2 | f ′ ( z 1 ))
| det J f ′ z ′ 1 | where the conditional distribution p ( z ′ 2 | f ′ ( z 1 )) is trainable.
It is useful to think of these factorization schemes as dimension reducing mechanisms from dim( z ′ ) to dim( z ′ 1 ) .
Increasing the dimensionality Dimension increasing flow layers can improve a models flexibility, as demonstrated by augmented normalizing flows [13].
To increase the dimensionality, x is embedded into a larger dimensional space and data independent noise u is added to the embedding to obtain a distribution with support of nonzero measure.
This noise addition x (cid:55)→ ( x, u ) is similar to dequantization [4, 22], but is orthogonal to the distribution of x and increases its dimension from dim x to dim x + dim u .
Under an augmentation the likelihood of x can be estimated using
[Equation]
[Equation]
In practice, we estimate this expectation value by sampling u everytime a datapoint is passed through the network.
This means the integral is estimated with a single sample as in surVAEs [15].
Flowification
Suppose A is a network architecture with parameter space Θ .
Then for any choice of θ ∈ Θ the network with parameters θ realizes a function A θ : R D → R C for some D and C .
Similarly, a normalizing flow model F is a parametric distribution on some R E , where for any choice of γ from their parameter space Γ they define a density function F γ on R E .
In this work we show that a large class of neural network architectures can be thought of as a flow model by constructing a map
[Equation]
The embedding of A to its flowification F A results in a flow model that can realize density functions on the augmented space R D × R N for some N ≥ 0 , which in turn induces a density on R D by integrating out the component on R N .
The parameter space of F A factorises as Θ × Φ where Θ is the parameter space of A and also that of the forward pass of F A , while Φ parametrises the inverse pass of F A .
In the simplest case Φ = ∅ , i.e. flowification does not require additional parameters.
It is in this sense that we claim that a large fraction of machine learning models are normalizing flows.
Terminology In what follows we work with conditional distributions such as p ( z | x ) and it will be practical to think of them as “stochastic functions” p : x (cid:55)→ z , that take an input x and produce an output z ∼ p ( z | x ) .
Conversely, we think of a function f : x (cid:55)→ z as the Dirac δ -distribution f
( z | x ) =
δ ( z − f ( x )) .
These definitions allow us to have a unified notation for deterministic and stochastic functions such that we can talk about them in the same language.
Consequently, when we say "stochastic function", it will include deterministic functions as a corner case.
Depending on whether f and f − 1 are deterministic or stochastic, we talk about left, right or two-sided inverses.
We will be careful to be precise about this.
Method In the following we consider the standard building blocks of machine learning architectures and enrich them by defining (stochastic-)inverse functions and calculating the likelihood contribution of each layer.
Treating each layer separately allows density estimation models to be built through composition [15].
The stochastic inverse can use the funnel approach, which increases the parameter count, or the multi-scale approach, which does not.
For simplicity we will only consider conditional densities in the inverse as this is more general, though it is not required.
We will refer to this process as flowification and the enriched layers as flowified ; non-flowified layers will be called standard layers .
Flowified layers can then be seen as simultaneously being
• Flow layers that are invertible, their likelihood contribution is known and therefore can be used to train the model to maximize the likelihood.
• Standard layers that can be trained with losses other than the likelihood, but for which the likelihood can be calculated after this training with fixed weights in the forward direction.
3.1 Linear Layers
Let L W,b : R n → R m denote the the linear layer of a neural network with parameters defined by a weight matrix W ∈ R m × n and bias b ∈ R m .
Formally, L W,b is defined as the affine function
[Equation]
Definition 1.
Let ϕ ( z | x ) : R n → R m be a stochastic function.
We say that ϕ is linear in expectation if there exists W ∈ R m × n and b ∈ R m such that for any x ∈ R n the expected value of ϕ coincides with the application of L W,b
[Equation]
Similarly, we say that a stochastic function ψ ( z | x ) is convolutional in expectation if the deterministic function x (cid:55)→ E z ∼ ψ ( z | x ) [ z ] is a convolutional layer.
In this section we flowify linear layers, by which we mean we construct a pair of stochastic functions, a forward L ( z | x ) :
R n → R m and an inverse L − 1 ( x | z ) : R m → R n such that the forward is linear in expectation and is compatible with the inverse in a way that will be made precise in the following paragraphs.
SVD parametrization
To build a flowified linear layer, the first step is to parametrize the weight matrices by the singular value decomposition (SVD)[23].
This involves writing W ∈ R m × n as a product W =
V Σ U , where
U ∈ R n × n is orthogonal, Σ ∈ R m × n is diagonal and V ∈
R m × m is orthogonal.
This parametrization is particularly useful for our purposes because the orthogonal transformations are easily invertible and do not contribute to the likelihood, and the non-invertible piece of the transformation is localized to Σ .
Parametrizing U and V
We generate elements of the special orthogonal group SO ( d ) by applying the matrix-exponential to elements of the Lie algebra so ( d ) of skew-symmetric matrices.
We parametrize so ( d ) and perform gradient descent there.
As the Lie-algebra is a vector space, this is significantly easier than working directly with SO ( d ) .
See Appendix G for details.
Parametrizing Σ
The matrix Σ is of shape m × n containing the singular values on the main diagonal.
We ensure maximal rank of Σ , by parameterizing the logarithm of the main diagonal, this way all singular values are greater than 0.
It is important to note that this parametrization is not without loss of generality.
In particular, it does not include matrices of non-maximal rank nor orientation reversing ones, where either
U ∈ O ( n ) \ SO ( n ) or
V ∈ O ( m ) \ SO ( m ) .
This implementation detail does not change the general perspective we provide of linear layers as normalizing flows, but instead simplifies the implementation of flowified layers.
Reducing the dimensionality
Definition 2.
We call the tuple ( L ( z | x ) , L − 1 ( x | z ))
a dimension decreasing flowified linear layer if
L is dimension decreasing, linear in expectation and the following conditions are satisfied
(i)
The forward is deterministic, given by L ( z | x ) =
L W,b ( x ) , (ii)
The layer is right-invertible, L ◦ L − 1 = id z , (iii)
The likelihood contribution of L can be exactly computed.
To flowify dimension decreasing linear layers, we define the forward function L as a standard linear layer with parameters W and b ,
[Equation]
Since W is parametrized by the SVD decomposition, W = V Σ U , we need to invert V, U and Σ separately.
As V and U are rotations, they are invertible in the usual sense.
To construct a stochastic inverse to Σ , we think of it as a funnel [14] and use a neural network p inv (( Ux ) ( m :) | Σ Ux ) that models the n − m dropped coordinates as a function of the m non-dropped coordinates.
Again, this is not required to calculate the likelihood under the model, even a fixed distribution could be used, but introducing some trainable parameters significantly improves the performance of the flow that is defined by the layer.
We use Σ − 1 to denote this stochastic inverse to Σ .
The stochastic inverse function L − 1 can then be written as
[Equation]
Since the rotations don’t contribute to the log-likelihood, the likelihood of data under a dimension decreasing flowified linear layer is
[Equation]
where log Σ denotes the sum of the logarithms of the diagonal elements of Σ .
Theorem 3.
The above choices for L and L − 1 define a dimension decreasing flowified linear layer.
Sketch of proof.
The definition of the forward pass (9) makes the forward pass linear in expectation and satisfies (i) by definition.
Unpacking the definitions and decomposing W into its SVD form yields right-invertibility (ii) which in turn implies that the likelihood contribution can be exactly computed (iii).
When the inverse density is not made to be conditional the above ideas can be visualized as a standard multi-scale flow architecture [4] as shown in Fig. [Figure]
Increasing the dimensionality
Definition 4.
We define the Moore-Penrose pseudoinverse L + W,b of a linear layer L W,b : R n → R m as the affine transformation R m → R n z (cid:55)→ L + W,b := W + ( z − b )
z ∈ R m (12) where
W + denotes the Moore-Penrose pseudoinverse of the matrix W .
Definition 5.
We call the tuple ( L ( z | x ) , L − 1 ( x | z ))
a dimension increasing flowified linear layer if
L is dimension increasing, linear in expectation and the following conditions are satisfied
(iv) The inverse L − 1 is deterministic, given by L − 1 ( x | z )
=
L + W,b ( z ) , (v) The layer is left-invertible, L − 1 ◦ L = id x , (vi) The likelihood contribution of L can be bounded from below.
To construct dimension increasing flowified linear layers, we rely again on the SVD parametrization where the only nontrivial component is Σ .
In this case Σ is a dimension increasing operation and we think of it as an augmentation step [13] composed with diagonal scaling.
To augment, we sample m − n coordinates from a distribution p ( u ) with zero mean and then apply a scaling in m dimensions.
The likelihood contribution is then given by
[Equation]
where log Σ denotes the sum of the logarithms of the m scaling parameters.
The inverse function
L − 1 is the composition of the inverse rotations, the inverse scaling and the dropping of the sampled coordinates.
This sequence of steps is visualized in Fig.
[Figure]
Theorem 6.
The above choices for L and L − 1 define a dimension increasing flowified linear layer.
Sketch of proof.
The augmentation step [13] results in a lower bound on the likelihood contribution, implying (vi).
Since E u ∼ p ( u ) = 0 , the augmentation does not influence the expected value of z , i.e. the forward pass is linear in expectation.
Simple calculations using the SVD decomposition then imply both (iv) and (v).
Preserving the dimensionality
Dimension preserving layers are a corner case of both of the above scenarios, where padding and sampling are not needed in either direction and the layer is non-stochastically invertible.
All this implies (i),(ii),(iii),(iv) and (v) are satisfied.
3.2 Convolutional layers
Convolutions can be seen as a dimension increasing coordinate repetition followed by a matrix multiplication with weight sharing.
In the previous section we derived the specifics of matrix multiplication.
We begin this section with the details of coordinate repetition after which we put the pieces together to build a flowified convolutional layer.
In Appendix H we describe an alternative approach relying on the Fourier transform.
Repeating coordinates In this paragraph we focus on the N -fold repetition of a single scalar coordinate x .
This significantly simplifies notation, but the technique generalizes in an obvious way.
Intuitively, the idea is to expand the one dimensional volume to N dimensions by first embedding and then increasing the volume of the embedding such that the volume in the N − 1 directions complementary to the embedding can be controlled.
We have seen in §2 that the operation
[Equation]
has likelihood contribution E u [ − log p ( u )] .
Now, we can apply any N -dimensional rotation R N which maps (1 , 0 ) to 1 √ N (1 , 1 ) to obtain[-
-]
[Equation]
Note that this rotation does not contribute to the likelihood.
Finally, we apply a diagonal scaling in N dimensions with factor √ N such that
[Equation]
where the final scaling has likelihood contribution N log( √ N ) =
( N/ 2) log N and x is now repeated
N times.
The overall contribution to the likelihood of the embedding (17) is
[Equation]
[Equation]
By construction, the padding distribution R N (0 , √ N u ) is orthogonal to the diagonal embedding x
(cid:55)→ ( x, ..., x ) of the data distribution.
The inverse function is given by the projection to the diagonal embedding,
[Equation]
General architectures Now that the likelihood contribution of arbitrary linear layers and coordinate repetition has been computed it is possible to flowify more general architectures such as convolutions and residual connections.
It is important to note that just because an architecture works well for certain tasks, it is not clear if its flowified version will perform well at density estimation.
Decomposing convolutional layers To flowify convolutional layers, we decompose it as a sequence of building blocks that are easy to flowify separately.
A standard convolutional layer performs the following sequence of steps:
Padding of the input image with zeros to increase its size.
Unfolding of the padded image into tiles.
This step replicates the data according to the kernel size and stride.
Applying a linear layer.
Finally, we apply the same linear layer to each of the tiles produced in the previous step.
The outputs then correspond to the pixels of the output image.
Flowification Steps 1 and 3 are already flowified, i.e. their likelihood contribution is computed and an inverse is constructed, in §3.1.
We denote their flowification with Pad and Linear , respectively.
Step 2 fits into the discussion of the previous paragraph of repeating coordinates, where both its inverse (19) and its likelihood contribution (18) are given.
We will denote this operation by Unfold .
Definition 7.
Let Linear , Unfold and Pad be as above and define C and C − 1 be the following stochastic functions
[Equation]
call the resulting layer ( C , C − 1 ) a flowified convolutional layer .
Augment
SVD SVD
A flowified convolutional layer ( C , C − 1 ) is then convolutional in expectation (Definition 1), i.e. there exists a convolutional layer C θ with parameters θ such that
[Equation]
The flowification of a convolution without padding can be seen in Fig.
The Unfold operation is implemented as coordinate duplication and Linear is a flowified linear layer parameterized by the
SVD.
Activation functions Functions that are surjective onto R and invertible fit well in our framework as they can be used out of the box without any modifications.
In our experiments we use LeakyReLU and rational-quadratic splines [5] as activations functions.
Non-invertible activations can also be used when equipped with additional densities [15].
Residual connections Residual connections can be seen as coordinate duplication followed by two separate computational graphs { f 1 , f 2 } with the outputs recombined in a sum.
The sum can be inverted by defining a density over one of the summands p ( f 1 ( x + u ) | f 1 ( x + u ) , f 2 ( x − u )) and sampling from this density, which will also define the likelihood contribution.
Then, if the likelihood contribution can be calculated for each individual computational graph, the likelihood of the total operation can be calculated [15].
Experiments
To test the constructions described in the previous section we flowify multilayer perceptrons and convolutional architectures and train them to maximize the likelihood of different datasets.
Tabular data In this section we study a selection of UCI datasets [24] and the BSDS 300 collection of natural images [25] using the preprocessed dataset used by masked autoregressive flows [17, 26].
We compare the performance with several baselines for comparison in Table 1.
We see that the flowified models have the right order of magnitude for the likelihood but are not competitive. [Table]
Image Data
In this section we use the MNIST [27] and CIFAR10 [28] datasets with the standard training and test splits.
The data is uniformly dequantized as required to train on image data [29, 30].
For both datasets we trained networks consisting only of flowified linear layers ( F MLP) and also networks consisting of convolutional layers followed by dense layers ( F C ONV 1).
To minimize the number of augmentation steps that occur in each model we define additional architectures with similar numbers of parameters but with non-overlapping kernels in the convolutional layers ( F C ONV 2).
The exact architectures can be found in Appendix F.1.
The flowified layers sample from N (0 , a ) for dimension increasing operations, where a is a per-layer trainable parameter.
We use rational quadratic splines [5] with 8 knots and a tail bound of 2 as activation functions, where the same function is applied per output node.
We also ran experiments with coupling layers using rational quadratic splines [5] mixed into F C ONV 2, in all other cases the parameters of the model are not data-dependent operations.
The improved performance of these models suggests that flowified layers do not mismodel the density of the data, but they do lack the capacity to model it well.
Samples from these models are shown in Appendix C.
[Table]
The results of the density modelling can be seen in Table.
The images in the left column of Fig.are generated by sampling from a standard gaussian in the latent space and taking the expected output of the inverse in every layer.
The images in the right column use the same latent samples as the left column but also sample from the distribution defined by the inverse pass of the layers.
As seen in Fig.
2 the F MLP models are outperformed by the F C ONV models and the convolutional models with non-overlapping kernels achieve better results than the ones with overlapping kernels.
This suggests both that the inductive bias of the convolution is useful for modelling distributions of images and that the augmentation step costs more in terms of likelihood than it provides in terms of increased expressivity.
Related Work
Several works have developed methods that allow standard layers to be made invertible, but these approaches restrict the space of the models, whereas we consider networks in their full generality.
Invertible ResNets [9, 10] require that each residual block has a Lipschitz constant less than one, but even with this restriction they attain competitive results on both classification and density estimation.
The same Lipschitz constraint can also be applied to other networks [11].
In these architectures the multi-scale architecture used in RealNVPs [4] is not leveraged, and so no information is discarded by the model.
It is unclear why this approach outperforms flowified layers, as seen in Table.
2, but it could be due to the preservation of information through the model, the very large number of parameters that are used in these approaches, the restricted subspace of the models, or some combination of these three.
It can also be shown that convolutions with the same number of input and output channels can be made invertible [12].
These layers perform poorly at the task of density estimation and are outperformed by flowified layers.
This is likely due to the increased expressivity that comes from considering a larger space of architectures.
There have been several works that develop convolution inspired invertible transformations [31–33], but these architectures consider restricted transformations to maintain invertibility.
Future Work and Conlusion
Our experiments suggest that flowified convolutional networks do not match the density estimation performance of similarly sized normalizing flows.
A possible explanation is that the dimension reducing steps discard information and more expressive encoding layers are necessary to transform the distributions before reducing the dimensionality.
This is supported by the experiments using NSF layers in-between the flowified layers (see App. C).
The addition of NSF layers leads to improved performance both in terms of visual quality and also BPD values.
Possibly the main limitation of a network consisting purely of flowified layers is the fact that, unlike flow layers, the forward passes of standard linear and convolutional layers are not data-dependent.
This is reinforced by the fact that the entanglement capability typically used in flows also appears in attention mechanisms, which have been shown to excel at capturing complex statistical structures [34–36].
With further development – such as increased capacity given to the inverse density, or data dependent parameters in the forward pass – standard architectures could become competitive density estimators in their own right and allow for general purpose models to be developed.
The focus of this work was on employing standard layers for density estimation, but it is possible that designing data dependent variants of standard layers that are more flow-like could improve their performance on tasks such as classification and regression.
The flowification procedure provides a useful means for designing such models and demonstrates that standard architectures can be considered a subset of normalizing flows, a correspondence that has not previously been demonstrated The code for reproducing our experiments is available under MIT license at https://github.com/balintmate/flowification .  Acknowledgement
The authors would like to acknowledge funding through the SNSF Sinergia grant called Robust Deep
Density Models for High-Energy Particle Physics and Solar Flare Analysis (RODEM) with funding number CRSII 5 _ 193716 .
A SurVAE
In this section we describe how the flowification procedure fits into the surVAE framework [15].
The surVAE framework can be used to compose bijective and surjective transformations such that the likelihood of the composition can be calculated exactly or bounded from below.
To define a likelihood for surjections both a forward and an inverse transformation is defined, where one of the directions is necessarily stochastic.
A transformation that is stochastic in the forward direction is called a generative surjection, and the likelihood of such transformations can only be bounded from below.
Flowified dimension increasing linear layers, residual connections, and coordinate repetition are examples of generative surjections.
A transformation that is stochastic in the inverse direction is called an inference surjection, where the likelihood can be calculated exactly if the layer satisfies the right inverse condition [15].
A flowified dimension reducing linear layer is an inference surjection that meets the right inverse condition.
The augmentation gap Dimension increasing operations (generative surjections) introduce an augmentation gap in the likelihood calculations as derived by Huang et al.
After this augmentation step the subsequent layers model the joint distribution p ( x, u ) of the data x and the augmenting noise u .
In this sense, the dimension increasing operations of this work are only normalizing flows to the degree to which augmented normalizing flows are normalizing flows.
The way we perform convolutions (pad, unfold, apply kernel) requires a large number of dimension expanding steps (unfold) and it is inevitable to work with this (weakened) version of flows.
If a convolutional layer is such that the dimensionality (channels times height times width) of its input is less than or equal than that of its output, the overall convolution operation is still in the dimension reducing regime, theoretically allowing to compute the exact likelihood.
We investigated this approach by diagonalizing the convolution using the Fourier transform, which unfortunately turned out to be too expensive computationally to be used in practice.
See Appendix H for details.
B Padding in dimension increasing operations
When flowifying a dimension increasing operation the choice of noise to use in the augmentation [13] plays an important role in the performance of the model.
In this section we compare sampling from a uniform distribution to sampling from a normal distribution.
In all cases we observe that sampling from a normal distribution is significantly better than sampling from a uniform distribution as seen in Table 3.
This is likely due to the normal distribution inverse that is used as the inverse in the dimension reducing layers as well as the normal base distribution.
[Table]
Implementation details
The flowification of convolutional layers involves an unfolding step as explained in §3.2.
This procedure entails the replication of all pixels values as many times as the number of patches the given pixel is contained in and the additional of orthogonal noise.
{+Our implementation relies on the Fold and Unfold operations of PyTorch and its essence is summarised in the following piece of pseudocode, 1 #Let X be the input image 
 # unfolding is a diagonal embedding for each pixel p -> (p,p, ...,p). 3 patches = unfold(X) 4 5 # generate the orthogonal noise in two steps 6 ### 1.+}
Uniformly sample the direction from the ### 7 ### (N-1)-sphere orthogonal to the diagonal ### 8 u_dir = torch.randn(patches.shape) 9 u_dir -= unfold(fold(u_dir ,aggr="mean") # center per input pixel 10 u_dir /= unfold(fold(u_dir**2, aggr="sum") # normalize per input pixel 11 12 ### 2. Sample the amplitude to make the ### 13 ### overall sample uniform on the N-ball ### 14 N = fold(unfold(torch.ones(
[Figure]
C Flowification + NSF
Below are samples from an architecture combining flowified standard layers and NSF layers. (a) Flowified convnets with non-overlapping kernels combined with NSF layers on MNIST, BPD 1. (b) Flowified convnets with overlapping kernels com- bined with NSF layers on MNIST, BPD 2. (c) Flowified convnets with non-overlapping kernels combined with NSF layers on CIFAR-10, BPD 3.
(d) Flowified convnets with overlapping kernels com- bined with NSF layers on CIFAR-10, BPD 3.
D Complete proofs of Theorems 3 and
Proof of Theorem 3.
The missing part of the proof is the calculation showing right invertibility.
To prove this, first we let z ∈ R
m be arbitrary and then we calculate
[Equation]
Proof of Theorem 6.
The missing part of the proof is showing that L − 1 =
L + W,b and that the resulting layer is left invertible.
To prove L − 1 =
L + W,b
we let z ∈ R m ,
[Equation]
Finally, left invertibility is proven by
[Equation]
E Samples from F MLP, F C ONV 1 and F C ONV
F Experimental details
Everything was implemented in PyTorch [37] and executed on a RTX 3090 GPU.
We also used weights and biases for experiment tracking [38] and the neural spline flows [39] package for the rational quadratic activation functions.
Both of these tools are available under an MIT license.
Tabular data
All training hyper parameters were set to be the same as those used in the neural spline flow experiments [5].
All networks in this section are flowified MLPs.
Several different architectures were tested with different design choices.
Dimension preserving layers of different depth were considered with the number of layers set to 3 , 5 , 7 , 9 , 21 .
Fixed depth layers were also considered with widths from 256 , 128 , 64 , 32 , 16 and depths from 3 , 5 , 7 .
We also tried hand designed widths with depths from [128 , 128 , 128 , 64 , 32] , [128 , 64 , 32 , 16 , 8] , [8 , 16 , 32 , 64 , 128] , [32 , 64 , 128 , 128 , 128] .
In all cases the second architecture was used, except for BSDS300 where the first architecture was used.
Leaky ReLU activations were used with a negative slope of 0.5.
Image data
The models on CIFAR- 10 were trained for 1000 epochs with a batch size of 256 and lasted 36hours.
The models on MNIST were trained for 200 epochs with the same batch size and lasted approximately 8-12 hours.
The learning rate in all experiments was initialized at 5 × 10 − 4 and annealed to 0 following a cosine schedule [40].
F.1 Architectures
1 import torch.nn as nn 2 import flowification as ffn 3 4 model = nn.
Sequential( ffn.
Flatten(), ffn.
Linear(784, 512), RqSpline(), ffn.
Linear(512, 256), RqSpline(), ffn.
Linear(256, 128), RqSpline(), ffn. Linear(128, 64), RqSpline(), ffn. Linear(64, 32), RqSpline(),
[Figure]
[Figure]
1 import torch.nn as nn 2 import flowification as ffn 3 4 model = nn.
Sequential( ffn.
Conv2d(3, 27, kernel_size=3, stride =2), RqSpline(), # ffn.
Conv2d(27, 64, kernel_size=3, stride =2), RqSpline(), # ffn. Conv2d(64, 100, kernel_size=3, stride =2), RqSpline(), # ffn.
Conv2d(100, 112, kernel_size=3, stride =2), RqSpline(), # ffn. Conv2d(112, 128, kernel_size=2, stride =2), RqSpline(), # ffn.
Flatten(), ffn.
Linear(128, 128), RqSpline(), ffn. Linear(128, 128), RqSpline(), ffn.
Linear(128, 128), RqSpline(), ffn. Linear(128, 128), RqSpline(), ffn.
Linear(128, 128), RqSpline(), ffn. Linear(128, 128), RqSpline(), ffn.
Linear(128, 128), RqSpline(), ffn. Linear(128, 128), RqSpline(), ffn.
Linear(128, 128), RqSpline(), ffn.
Linear(128, 128), RqSpline() )
[Figure]
as nn
[Figure]
as [Figure] [Figure] = nn.
Sequential( ffn.
Conv2d(1, 16, kernel_size=3, stride =2), RqSpline(), # ffn.
Conv2d(16, 24, kernel_size=2, stride =2), RqSpline(), # ffn. Conv2d(24, 32, kernel_size=3, stride =2), RqSpline(), # ffn.
Conv2d(32, 48, kernel_size=2, stride =1), RqSpline(), # ffn. Conv2d(48, 64, kernel_size=2, stride =1), RqSpline(), # ffn.
Flatten(), ffn.
Linear(64, 64), RqSpline(), ffn. Linear(64, 64), RqSpline(), ffn.
Linear(64, 64), RqSpline(), ffn. Linear(64, 64), RqSpline(), ffn.
Linear(64, 64), RqSpline(), ffn. Linear(64, 64), RqSpline(), ffn.
Linear(64, 32), RqSpline(), ffn. Linear(32, 32), RqSpline(), ffn.
Linear(32, 32), RqSpline(), ffn. Linear(32, 32), RqSpline(), ffn.
Linear(32, 32), RqSpline(), ffn. Linear(32, 32), RqSpline(), ffn.
Linear(32, 32), RqSpline(), ffn.
Linear(32, 8), RqSpline() )
G Parametrizing rotations via the Lie algebra so ( d )
The Lie algebra so ( d ) of the rotation group SO ( d ) is the space of d × d skew-symmetric matrices
[Equation]
Moreover, since SO ( d ) is connected and compact, the (matrix-)exponential map so ( d ) → SO ( d ) is surjective [41, Corollary 11.10],
i.e. every rotation U ∈ SO ( d ) can be written as the exponential of some skew-symmetric X ∈ so ( d ) .
Motivated by this result, we propose to parametrize the Lie algebra so ( d ) , and use the exponential map to obtain rotations.
Since the exponential map is differentiable, we can propagate gradients all the way back to the Lie algebra and do gradient based optimization there.
Note that is significantly eases the optimization process.
The reason for this is that the Lie group of unitary transformations has non-trivial geometry and doing gradient descent is cumbersome on such spaces.
On the other hand, the Lie algebra is a vector space, where gradient descent can shine.
Since PyTorch [37] has built-in support for the matrix exponential, random orthogonal transformations can be generated with just a few lines of Python code: [Equation]
[Figure]
[Equation]
transformations The matrix exponential has the advantage of generating the whole rotation group, while many Householder transformations need to be composed to have the same level of expressivity.
This, of course, comes with an increased ( O ( d 2 ) ) computational cost.
We did not explore Householder transformations, but we expect that for linear layers with large input or output dimensionality, the matrix exponential will simply become too expensive and it will become necessary to rely on Householder transformations.
H Flowifying convolutions through the FFT
An alternative way of flowifing convolutional layers is through the convolution theorem which states that the Fourier-transformation diagonalizes convolutions.
In this section we sketch the idea and discuss the issues with it.
Fig.13 displays the Pytorch code for performing convolutions through the convolution theorem.
Line 12 of the code shows that in the Fourier basis, we can perform convolution as follows; at each frequency we form the vector of dimension (# of in_channels) and apply a weight matrix of size (# of in_channels) × (# of out_channels) to it.
If this weight matrix is parametrized by the SVD, we can guarantee its invertibility.
Since the FFT is also invertible, this construction should be a flowification of the convolutional layer if we can also solve the following two issues:
If the weight matrix is parametrized in frequency domain,
(1) it’s inverse transform might not be real.
(2) it’s inverse transform might not be of the appropriate size (i.e. nonzero outside of the first (kernel_size)-many pixels).
The first of these is easy to solve with the symmetric parametrization induced by [Equation] where N is the length of the signal.
To deal with the second condition, a auxiliary loss term is introduced that minimizes the terms that should be 0 .
Although the idea of FFT seems promising, this approach turns out be slower (probably due to the FFT), worse performing and more cumbersome than the flowificaton presented in §3.2.
Fig.
14 shows some samples from a Fourier-flowified convolutional network trained on MNIST.
{+in_channels , out_channels = 4, signal_length , kernel_size = 32, batch_size =
+}
K = torch.randn(out_channels , in_channels , kernel_size) x = torch.randn(batch_size , in_channels , signal_length) z1 = torch.nn.functional.conv1d(input=x, weight=K) 8x_ = torch.fft.fft(x, norm=’ortho’)
# pad kernel to match the length of x
K_ = torch.fft.fft(K.flip(-1), n=x.size()[-1], norm=’ortho’)
z_
= torch.einsum(’bix ,jix ->bjx’, (x_, K_))
z2 = torch.fft.ifft(z_, norm=’forward’)
{+z2 = z
+}
[:, :, (kernel_size -1):] 15print((z1-z2).abs().max().item())
# tensor (2.8610e-06)