Residual Flows for Invertible Generative Modeling

Introduction

Maximum likelihood is a core machine learning paradigm that poses learning as a distribution alignment problem. However, it is often unclear what family of distributions should be used to fit high-dimensional continuous data. In this regard, the change of variables theorem offers an appealing way to construct flexible distributions that allow tractable exact sampling and efficient evaluation of its density. This class of models is generally referred to as invertible or flow-based generative models (Deco and Brauer, 1995; Rezende and Mohamed, 2015).

With invertibility as its core design principle, flow-based models (also referred to as normalizing flows) have shown to be capable of generating realistic images (Kingma and Dhariwal, 2018) and can achieve density estimation performance on-par with competing state-of-the-art approaches (Ho et al., 2019). In applications, they have been applied to study adversarial robustness (Jacobsen et al., 2019) and are used to train hybrid models with both generative and classification capabilities (Nalisnick et al., 2019) using a weighted maximum likelihood objective.

Existing flow-based models (Rezende and Mohamed, 2015; Kingma et al., 2016; Dinh et al., 2014; Chen et al., 2018) make use of restricted transformations with sparse or structured Jacobians (Figure 1). These allow efficient computation of the log probability under the model but at the cost of architectural engineering. Transformations that scale to high-dimensional data rely on specialized architectures such as coupling blocks (Dinh et al., 2014, 2017) or solving an ordinary differential equation (Grathwohl et al., 2019). Such approaches have a strong inductive bias that can hinder their application in other tasks, such as learning representations that are suitable for both generative and discriminative tasks.

Recent work by Behrmann et al. (2019) showed that residual networks (He et al., 2016) can be made invertible by simply enforcing a Lipschitz constraint, allowing to use a very successful discriminative deep network architecture for unsupervised flow-based modeling. Unfortunately, the density evaluation requires computing an infinite series. The choice of a fixed truncation estimator used by Behrmann et al. (2019) leads to substantial bias that is tightly coupled with the expressiveness of the network, and cannot be said to be performing maximum likelihood as bias is introduced in the objective and gradients.

In this work, we introduce Residual Flows, a flow-based generative model that produces an unbiased estimate of the log density and has memory-efficient backpropagation through the log density computation. This allows us to use expressive architectures and train via maximum likelihood. Furthermore, we propose and experiment with the use of activations functions that avoid derivative saturation and induced mixed norms for Lipschitz-constrained neural networks.

Background

To perform maximum likelihood with stochastic gradient descent, it is sufficient to have an unbiased estimator for the gradient as

where $p_{\textnormal{data}}$ is the unknown data distribution which can be sampled from and $p_{\theta}$ is the model distribution. An unbiased estimator of the gradient also immediately follows from an unbiased estimator of the log density function, $\log p_{\theta}(x)$.

Change of variables theorem.

With an invertible transformation $f$, the change of variables

captures the change in density of the transformed samples. A simple base distribution such as a standard normal is often used for $\log p(f(x))$. Tractable evaluation of (2) allows flow-based models to be trained using the maximum likelihood objective (1). In contrast, variational autoencoders (Kingma and Welling, 2014) can only optimize a stochastic lower bound, and generative adversial networks (Goodfellow et al., 2014) require an extra discriminator network for training.

Invertible residual networks (i-ResNets).

Residual networks are composed of simple transformations $y=f(x)=x+g(x)$. Behrmann et al. (2019) noted that this transformation is invertible by the Banach fixed point theorem if $g$ is contractive, i.e. with Lipschitz constant strictly less than unity, which was enforced using spectral normalization (Miyato et al., 2018; Gouk et al., 2018).

Applying i-ResNets to the change-of-variables (2), the identity

was shown, where $J_{g}(x)=\frac{dg(x)}{dx}$. Furthermore, the Skilling-Hutchinson estimator (Skilling, 1989; Hutchinson, 1990) was used to estimate the trace in the power series. Behrmann et al. (2019) used a fixed truncation to approximate the infinite series in (3). However, this naïve approach has a bias that grows with the number of dimensions of $x$ and the Lipschitz constant of $g$, as both affect the convergence rate of this power series. As such, the fixed truncation estimator requires a careful balance between bias and expressiveness, and cannot scale to higher dimensional data. Without decoupling the objective and estimation bias, i-ResNets end up optimizing for the bias without improving the actual maximum likelihood objective (see Figure 2).

Residual Flows

Evaluation of the exact log density function $\log p_{\theta}(\cdot)$ in (3) requires infinite time due to the power series. Instead, we rely on randomization to derive an unbiased estimator that can be computed in finite time (with probability one) based on an existing concept (Kahn, 1955).

To illustrate the idea, let $\Delta_{k}$ denote the $k$-th term of an infinite series, and suppose we always evaluate the first term then flip a coin $b\sim\textnormal{Bernoulli}(q)$ to determine whether we stop or continue evaluating the remaining terms. By reweighting the remaining terms by $\frac{1}{1-q}$, we obtain an unbiased estimator

Interestingly, whereas naïve computation would always use infinite compute, this unbiased estimator has probability $q$ of being evaluated in finite time. We can obtain an estimator that is evaluated in finite time with probability one by applying this process infinitely many times to the remaining terms. Directly sampling the number of evaluated terms, we obtain the appropriately named “Russian roulette” estimator (Kahn, 1955)

We note that the explanation above is only meant to be an intuitive guide and not a formal derivation. The peculiarities of dealing with infinite quantities dictate that we must make assumptions on $\Delta_{k}$, $p(N)$, or both in order for the equality in (5) to hold. While many existing works have made different assumptions depending on specific applications of (5), we state our result as a theorem where the only condition is that $p(N)$ must have support over all of the indices.

where $n\sim p(N)$ and $v\sim\mathcal{N}(0,I)$.

Here we have used the Skilling-Hutchinson trace estimator (Skilling, 1989; Hutchinson, 1990) to estimate the trace of the matrices $J_{g}^{k}$. A detailed proof is given in Appendix B.

Note that since $J_{g}$ is constrained to have a spectral radius less than unity, the power series converges exponentially. The variance of the Russian roulette estimator is small when the infinite series exhibits fast convergence (Rhee and Glynn, 2015; Beatson and Adams, 2019), and in practice, we did not have to tune $p(N)$ for variance reduction. Instead, in our experiments, we compute two terms exactly and then use the unbiased estimator on the remaining terms with a single sample from $p(N)=\textnormal{Geom}(0.5)$. This results in an expected compute cost of $4$ terms, which is less than the $5$ to $10$ terms that Behrmann et al. (2019) used for their biased estimator.

Theorem 1 forms the core of Residual Flows, as we can now perform maximum likelihood training by backpropagating through (6) to obtain unbiased gradients. This allows us to train more expressive networks where a biased estimator would fail (Figure 2). The price we pay for the unbiased estimator is variable compute and memory, as each sample of the log density uses a random number of terms in the power series.

2 Memory-Efficient Backpropagation

Memory can be a scarce resource, and running out of memory due to a large sample from the unbiased estimator can halt training unexpectedly. To this end, we propose two methods to reduce the memory consumption during training.

To see how naïve backpropagation can be problematic, the gradient w.r.t. parameters $\theta$ by directly differentiating through the power series (6) can be expressed as

Unfortunately, this estimator requires each term to be stored in memory because $\nicefrac{{\partial}}{{\partial\theta}}$ needs to be applied to each term. The total memory cost is then $\mathcal{O}(n\cdot m)$ where $n$ is the number of computed terms and $m$ is the number of residual blocks in the entire network. This is extremely memory-hungry during training, and a large random sample of $n$ can occasionally result in running out of memory.

Instead, we can specifically express the gradients as a power series derived from a Neumann series (see Appendix C). Applying the Russian roulette and trace estimators, we obtain the following theorem.

where $n\sim p(N)$ and $v\sim\mathcal{N}(0,I)$.

As the power series in (8) does not need to be differentiated through, using this reduces the memory requirement by a factor of $n$. This is especially useful when using the unbiased estimator as the memory will be constant regardless of the number of terms we draw from $p(N)$.

Backward-in-forward: early computation of gradients.

We can further reduce memory by partially performing backpropagation during the forward evaluation. By taking advantage of $\log\det(I+J_{g}(x,\theta))$ being a scalar quantity, the partial derivative from the objective $\mathcal{L}$ is

For every residual block, we compute $\nicefrac{{\partial\log\det(I+J_{g}(x,\theta))}}{{\partial\theta}}$ along with the forward pass, release the memory for the computation graph, then simply multiply by $\nicefrac{{\partial\mathcal{L}}}{{\partial\log\det(I+J_{g}(x,\theta))}}$ later during the main backprop. This reduces memory by another factor of $m$ to $\mathcal{O}(1)$ with negligible overhead.

Note that while these two tricks remove the memory cost from backpropagating through the $\log\det$ terms, computing the path-wise derivatives from $\log p(f(x))$ still requires the same amount of memory as a single evaluation of the residual network. Figure 3 shows that the memory consumption can be enormous for naïve backpropagation, and using large networks would have been intractable.

3 Avoiding Derivative Saturation with the LipSwish Activation Function

As the log density depends on the first derivatives through the Jacobian $J_{g}$, the gradients for training depend on second derivatives. Similar to the phenomenon of saturated activation functions, Lipschitz-constrained activation functions can have a derivative saturation problem. For instance, the ELU activation used by Behrmann et al. (2019) achieves the highest Lipschitz constant when $\textnormal{ELU}^{\prime}(z)=1$, but this occurs when the second derivative is exactly zero in a very large region, implying there is a trade-off between a large Lipschitz constant and non-vanishing gradients.

We thus desire two properties from our activation functions $\phi(z)$:

The first derivatives must be bounded as $|\phi^{\prime}(z)|\leq 1$ for all $z$

The second derivatives should not asymptotically vanish when $|\phi^{\prime}(z)|$ is close to one.

While many activation functions satisfy condition 1, most do not satisfy condition 2. We argue that the ELU and softplus activations are suboptimal due to derivative saturation. Figure 4 shows that when softplus and ELU saturate at regions of unit Lipschitz, the second derivative goes to zero, which can lead to vanishing gradients during training.

We find that good activation functions satisfying condition 2 are smooth and non-monotonic functions, such as Swish (Ramachandran et al., 2017). However, Swish by default does not satisfy condition 1 as $\max_{z}|\frac{d}{dz}\textnormal{Swish}(z)|\apprle 1.1$. But scaling via

where $\sigma$ is the sigmoid function, results in $\max_{z}|\frac{d}{dz}\textnormal{LipSwish}(z)|\leq 1$ for all values of $\beta$. LipSwish is a simple modification to Swish that exhibits a less than unity Lipschitz property. In our experiments, we parameterize $\beta$ to be strictly positive by passing it through softplus. Figure 4 shows that in the region of maximal Lipschitz, LipSwish does not saturate due to its non-monotonicity property.

Related Work

Our derivation of the unbiased estimator follows from the general approach of using a randomized truncation (Kahn, 1955). This paradigm of estimation has been repeatedly rediscovered and applied in many fields, including solving of stochastic differential equations (McLeish, 2011; Rhee and Glynn, 2012, 2015), ray tracing for rendering paths of light (Arvo and Kirk, 1990), and estimating limiting behavior of optimization problems (Tallec and Ollivier, 2017; Beatson and Adams, 2019), among many other applications. Some recent works use Chebyshev polynomials to estimate the spectral functions of symmetric matrices (Han et al., 2018; Adams et al., 2018; Ramesh and LeCun, 2018). These works estimate quantities that are similar to those presented in this work, but a key difference is that the Jacobian in our power series is not symmetric. Works that proposed the random truncation approach typically made assumptions on $p(N)$ in order for it to be applicable to general infinite series (McLeish, 2011; Rhee and Glynn, 2015; Han et al., 2018). Fortunately, since the power series in Theorems 1 and 2 converge fast enough, we were able to make use of a different set of assumptions requiring only that $p(N)$ has sufficient support (details in Appendix B).

Memory-efficient Backpropagation.

The issue of computing gradients in a memory-efficient manner was explored by Gomez et al. (2017) and Chang et al. (2018) for residual networks with a coupling-based architecture devised by Dinh et al. (2014), and explored by Chen et al. (2018) for a continuous analogue of residual networks. These works focus on the path-wise gradients from the output of the network, whereas we focus on the gradients from the log-determinant term in the change of variables equation specifically for generative modeling. On the other hand, our approach shares some similarities with Recurrent Backpropagation (Almeida, 1987; Pineda, 1987; Liao et al., 2018), since both approaches leverage convergent dynamics to modify the derivatives.

Invertible Deep Networks.

Flow-based generative models are a density estimation approach which has invertibility as its core design principle (Rezende and Mohamed, 2015; Deco and Brauer, 1995). Most recent work on flows focuses on designing maximally expressive architectures while maintaining invertibility and tractable log determinant computation (Dinh et al., 2014, 2017; Kingma and Dhariwal, 2018). An alternative route has been taken by Continuous Normalizing Flows (Chen et al., 2018) which make use of Jacobian traces instead of Jacobian determinants, provided that the transformation is parameterized by an ordinary differential equation. Invertible architectures are also of interest for discriminative problems, as their information-preservation properties make them suitable candidates for analyzing and regularizing learned representations (Jacobsen et al., 2019).

Experiments

We use a similar architecture as Behrmann et al. (2019), except without the immediate invertible downsampling (Dinh et al., 2017) at the image pixel-level. Removing this substantially increases the amount of memory required (shown in Figure 3) as there are more spatial dimensions at every layer, but increases the overall performance. We also increase the bound on the Lipschitz constants of each weight matrix to $0.98$, whereas Behrmann et al. (2019) used $0.90$ to reduce the error of the biased estimator. More detailed description of architectures is in Appendix E.

Unlike prior works that use multiple GPUs, large batch sizes, and a few hundred epochs, Residual Flow models are trained with the standard batch size of 64 and converges in roughly 300-350 epochs for MNIST and CIFAR-10. Most network settings can fit on a single GPU (see Figure 3), though we use 4 GPUs in our experiments to speed up training. On CelebA-HQ, Glow had to use a batchsize of 1 per GPU with a budget of 40 GPUs whereas we trained our model using a batchsize of 3 per GPU and a budget of 4 GPUs, owing to the smaller model and memory-efficient backpropagation.

Furthermore, it is possible to generalize the Lipschitz condition of Residual Flows to arbitrary p-norms and even mixed matrix norms. By learning the norm orders jointly with the model, we achieved a small gain of 0.003 bits/dim on CIFAR-10 compared to spectral normalization. In addition, we show that others norms like $p=\infty$ yielded constraints more suited for lower dimensional data. See Appendix D for a discussion on how to generalize the Lipschitz condition and an exploration of different norm-constraints for 2D problems and image data.

2 Sample Quality

We are also competitive with state-of-the-art flow-based models in regards to sample quality. Figure 5 shows random samples from the model trained on CelebA. Furthermore, samples from Residual Flow trained on CIFAR-10 are more globally coherent (Figure 6) than PixelCNN and variational dequantized Flow++, even though our likelihood is worse.

For quantitative comparison, we report FID scores (Heusel et al., 2017) in Table 2. We see that Residual Flows significantly improves on i-ResNets and PixelCNN, and achieves slightly better sample quality than an official Glow model that has double the number of layers. It is well-known that visual fidelity and log-likelihood are not necessarily indicative of each other (Theis et al., 2015), but we believe residual blocks may have a better inductive bias than coupling blocks or autoregressive architectures as generative models. More samples are in Appendix A.

To generate visually appealing images, Kingma and Dhariwal (2018) used temperature annealing (ie. sampling from $[p(x)]^{T^{2}}$ with $T<1$) to sample closer to the mode of the distribution, which helped remove artifacts from the samples and resulted in smoother looking images. However, this is done by reducing the entropy of $p(z)$ during sampling, which is only equivalent to temperature annealing if the change in log-density does not depend on the sample itself. Intuitively, this assumption implies that the mode of $p(x)$ and $p(z)$ are the same. As this assumption breaks for general flow-based models, including Residual Flows, we cannot use the same trick to sample efficiently from a temperature annealed model. Figure 7 shows the results of reduced entropy sampling on CelebA-HQ 256, but the samples do not converge to the mode of the distribution.

3 Ablation Experiments

We report ablation experiments for the unbiased estimator and the LipSwish activation function in Table 9. Even in settings where the Lipschitz constant and bias are relatively low, we observe a significant improvement from using the unbiased estimator. Training the larger i-ResNet model on CIFAR-10 results in the biased estimator completely ignoring the actual likelihood objective altogether. In this setting, the biased estimate was lower than 0.8 bits/dim by 50 epochs, but the actual bits/dim wildly oscillates above 3.66 bits/dim and seems to never converge. Using LipSwish not only converges much faster but also results in better performance compared to softplus or ELU, especially in the high Lipschitz settings (Figure 9 and Table 9).

4 Hybrid Modeling

Next, we experiment on joint training of continuous and discrete data. Of particular interest is the ability to learn both a generative model and a classifier, referred to as a hybrid model which is useful for downstream applications such as semi-supervised learning and out-of-distribution detection (Nalisnick et al., 2019). Let $x$ be the data and $y$ be a categorical random variable. The maximum likelihood objective can be separated into $\log p(x,y)=\log p(x)+\log p(y|x)$, where $\log p(x)$ is modeled using a flow-based generative model and $\log p(y|x)$ is a classifier network that shares learned features from the generative model. However, it is often the case that accuracy is the metric of interest and log-likelihood is only used as a surrogate training objective. In this case, (Nalisnick et al., 2019) suggests a weighted maximum likelihood objective,

where $\lambda$ is a scaling constant. As $y$ is much lower dimensional than $x$, setting $\lambda<1$ emphasizes classification, and setting $\lambda=0$ results in a classification-only model which can be compared against.

Since Nalisnick et al. (2019) performs approximate Bayesian inference and uses a different architecture than us, we perform our own ablation experiments to compare residual blocks to coupling blocks (Dinh et al., 2014) as well as 1$\times$1 convolutions (Kingma and Dhariwal, 2018). We use the same architecture as the density estimation experiments and append a classification branch that takes features at the final output of multiple scales (see details in Appendix E). This allows us to also use features from intermediate blocks whereas Nalisnick et al. (2019) only used the final output of the entire network for classification. Our implementation of coupling blocks uses the same architecture for $g(x)$ except we use ReLU activations and no longer constrain the Lipschitz constant.

Tables 3 & 4 show our experiment results. Our architecture outperforms Nalisnick et al. (2019) on both pure classification and hybrid modeling. Furthermore, on MNIST we are able to jointly obtain a decent classifier and a strong density model over all settings. In general, we find that residual blocks perform much better than coupling blocks at learning representations for both generative and discriminative tasks. Coupling blocks have very high bits per dimension when $\lambda=\nicefrac{{1}}{{D}}$ while performing worse at classification when $\lambda=1$, suggesting that they have restricted flexibility and can only perform one task well at a time.

Conclusion

We have shown that invertible residual networks can be turned into powerful generative models. The proposed unbiased flow-based generative model, coined Residual Flow, achieves competitive or better performance compared to alternative flow-based models in density estimation, sample quality, and hybrid modeling. More generally, we gave a recipe for introducing stochasticity in order to construct tractable flow-based models with a different set of constraints on layer architectures than competing approaches, which rely on exact log-determinant computations. This opens up a new design space of expressive but Lipschitz-constrained architectures that has yet to be explored.

Acknowledgments

Jens Behrmann gratefully acknowledges the financial support from the German Science Foundation for RTG 2224 “$\pi^{3}$: Parameter Identification - Analysis, Algorithms, Applications”

References

Appendix A Random Samples

Appendix B Proofs

We start by formulating a Lemma, which gives the condition when the randomized truncated series is an unbiased estimator in a fairly general setting. Afterwards, we study our specific estimator and prove that the assumption of the Lemma is satisfied.

Note, that similar conditions have been stated in previous works, e.g. in McLeish (2011) and Rhee and Glynn (2012). However, we use the condition from Bouchard-Côté (2018), which only requires $p(N)$ to have sufficient support.

To make the derivations self-contained, we reformulate the conditions from Bouchard-Côté (2018) in the following way:

and let $N$ be a random variable with support over the positive integers and $n\sim p(N)$. Then for

where the assumption is used in the last step. Using the above, the dominated convergence theorem can be used to swap the limit and expectation for $Z_{M}$. Using similar derivations as above, it is

(Theorem 1) To simplify notation, we denote $J:=J_{g}(x)$. Furthermore, let

To show that (12) is bounded, we derive the bound

Hence, the assumption of Lemma 3 is verified. ∎

(Theorem 2) The result can be proven in an analogous fashion to the proof of Theorem 1, which is why we only present a short version without all steps.

Appendix C Memory-Efficient Gradient Estimation of Log-Determinant

Derivation of gradient estimator via differentiating power series:

Derivation of memory-efficient gradient estimator:

Note, that (13) follows from the chain rule of differentiation, for the derivative of the determinant in (14), see (Petersen and Pedersen, 2012, eq. 46). Furthermore, (15) follows from the properties of a Neumann-Series which converges due to $\|J_{g}(x,\theta)\|<1$.

Hence, if we are able to compute the trace exactly, both approaches will return the same values for a given truncation $n$. However, when estimating the trace via the Hutchinson trace estimator the estimation is not equal in general:

This is due to the terms in these infinite series being different.

Another difference between both approaches is their memory consumption of the corresponding computational graph. The summation $\sum_{k=0}^{\infty}(-1)^{k}J_{g}^{k}(x,\theta)$ is not being tracked for the gradient, which allows to compute the gradient with constant memory with respect to the truncation $n$.

Appendix D Generalizing Lipschitz Constraints to Induced Mixed Norms

Behrmann et al. (2019) used spectral normalization (Miyato et al., 2018) (which relies on power iteration to approximate the spectral norm) to enforce the Lipschitz constraint on $g$. Specifically, this bounds the spectral norm of the Jacobian $J_{g}$ by the sub-multiplicativity property. If $g(x)$ is a neural network with pre-activation defined recursively using $z_{l}=W_{l}h_{l-1}+b_{l}$ and $h_{l}=\phi(z_{l})$, with $x=z_{0},g(x)=z_{L}$, then the data-independent upper bound

holds, where $\phi^{\prime}(z)$ are diagonal matrices containing the first derivatives of the activation functions. The inequality in (16) is a result of using a sub-multiplicative norm and assuming that the activation functions have Lipschitz less than unity. However, any induced matrix norm satisfies the sub-multiplicativity property, including mixed norms $||W||_{p\rightarrow q}:=\sup_{x\neq 0}\nicefrac{{||Wx||_{q}}}{{||x||_{p}}}$, where the input and output spaces have different vector norms.

As long as $g(x)$ maps back to the original normed (complete) vector space, the Banach fixed point theorem used in the proof of invertibility of residual blocks (Behrmann et al., 2019) still holds. As such, we can choose arbitrary $p_{0},\dots,p_{L-2}\in[1,\infty]$ such that

We use a more general form of power iteration (Johnston, 2016) for estimating induced mixed norms, which becomes the standard power iteration for $p=q=2$. Furthermore, the special cases where $p_{l}=1$ or $p_{l}=\infty$ are of particular interest, as the matrix norms can be computed exactly (Tropp, 2004). Additionally, we can also optimize the norm orders during training by backpropagating through the modified power method. Lastly, we emphasize that the convergence of the infinite series (3) is guaranteed for any induced matrix norm, as they still upper bound the spectral radius (Horn and Johnson, 2012).

Figure 16(a) shows that we obtain some performance gain by using either learned norms or the infinity norm on a difficult 2D dataset, where similar performance can be achieved by using fewer residual blocks. While the infinity norm works well with fully connected layers, we find that it does not perform as well as the spectral norm for convolutional networks. Instead, learned norms always perform slightly better and was able to obtain an improvement of 0.003 bits/dim on CIFAR-10. Ultimately, while the idea of generalizing spectral normalization via learnable norm orders is interesting in its own right to be communicated here, we found that the improvements are very marginal.

We experimented with the checkerboard 2D dataset, which is a rather difficult two-dimensional data to fit a flow-based model on due to the discontinuous nature of the true distribution. We used brute-force computation of the log-determinant for change of variables (which, in the 2D case, is faster than the unbiased estimator). In the 2D case, we found that $\infty$-norm always outperforms or at least matches the $p=2$ norm (ie. spectral norm). Figure 17 shows the learned densities with 200 residual blocks. The color represents the magnitude of $p_{\theta}(x)$, with brighter values indicating larger values. The $\infty$-norm model produces density estimates that are more evenly spread out across the space, whereas the spectral norm model focused its density to model between-density regions.

Learning norm orders on CIFAR-10.

We used $1+\textnormal{tanh}(s)/2$ where $s$ is a learned weight. This bounds the norm orders to $(1.5,2.5)$. We tried two different setups. One where all norm orders are free to change (conditioned on them satisfying the constraints (17)), and another setting where each states within each residual block share the same order. Figure 18 shows the improvement in bits from using learned norms. The gain in performance is marginal, and the final models only outperformed spectral norm by around $0.003$ bits/dim. Interestingly, we found that the learned norms stayed around $p=2$, shown in Figure 19, especially for the input and output spaces of $g$, ie. between blocks. This may suggest that spectral norm, or a norm with $p=2$ is already optimal in this setting.

Appendix E Experiment Setup

We use the standard setup of passing the data through a “unsquashing” layer (we used the logit transform (Dinh et al., 2017)), followed by alternating multiple blocks and squeeze layers (Dinh et al., 2017). We use activation normalization (Kingma and Dhariwal, 2018) before and after every residual block. Each residual connection consists of

LipSwish $\rightarrow$ 3$\times$3 Conv $\rightarrow$ LipSwish $\rightarrow$ 1$\times$1 Conv $\rightarrow$ LipSwish $\rightarrow$ 3$\times$3 Conv

with hidden dimensions of $512$. Below are the architectures for each dataset.

Image $\rightarrow$ LogitTransform($\alpha$) $\rightarrow$ 16$\times$ResBlock $\rightarrow$ [ Squeeze $\rightarrow$ 16$\times$ResBlock ]$\times$2

CIFAR-10.

Image $\rightarrow$ LogitTransform($\alpha$) $\rightarrow$ 16$\times$ResBlock $\rightarrow$ [ Squeeze $\rightarrow$ 16$\times$ResBlock ]$\times$2

SVHN.

Image $\rightarrow$ LogitTransform($\alpha$) $\rightarrow$ 16$\times$ResBlock $\rightarrow$ [ Squeeze $\rightarrow$ 16$\times$ResBlock ]$\times$2

ImageNet 32×\times32.

Image $\rightarrow$ LogitTransform($\alpha$) $\rightarrow$ 32$\times$ResBlock $\rightarrow$ [ Squeeze $\rightarrow$ 32$\times$ResBlock ]$\times$2

ImageNet 64×\times64.

Image $\rightarrow$ Squeeze $\rightarrow$ LogitTransform($\alpha$) $\rightarrow$ 32$\times$ResBlock $\rightarrow$ [ Squeeze $\rightarrow$ 32$\times$ResBlock ]$\times$2

CelebA 5bit 64×\times64.

Image $\rightarrow$ Squeeze $\rightarrow$ LogitTransform($\alpha$) $\rightarrow$ 16$\times$ResBlock $\rightarrow$ [ Squeeze $\rightarrow$ 16$\times$ResBlock ]$\times$3

CelebA 5bit 256×\times256.

Image $\rightarrow$ Squeeze $\rightarrow$ LogitTransform($\alpha$) $\rightarrow$ 16$\times$ResBlock $\rightarrow$ [ Squeeze $\rightarrow$ 16$\times$ResBlock ]$\times$5

For density modeling on MNIST and CIFAR-10, we added 4 fully connected residual blocks at the end of the network, with intermediate hidden dimensions of 128. These residual blocks were not used in the hybrid modeling experiments or on other datasets. For datasets with image size higher than 32$\times$32, we factored out half the variables after every squeeze operation other than the first one.

For hybrid modeling on CIFAR-10, we replaced the logit transform with normalization by the standard preprocessing of subtracting the mean and dividing by the standard deviation across the training data. The MNIST and SVHN architectures for hybrid modeling were the same as those for density modeling.

For augmenting our flow-based model with a classifier in the hybrid modeling experiments, we added an additional branch after every squeeze layer and at the end of the network. Each branch consisted of

3$\times$3 Conv $\rightarrow$ ActNorm $\rightarrow$ ReLU $\rightarrow$ AdaptiveAveragePooling(($1,1$))

where the adaptive average pooling averages across all spatial dimensions and resulted in a vector of dimension $256$. The outputs at every scale were concatenated together and fed into a linear softmax classifier.

Adaptive number of power iterations.

We used spectral normalization for convolutions (Gouk et al., 2018). To account for variable weight updates during training, we implemented an adaptive version of spectral normalization where we performed as many iterations as needed until the relative change in the estimated spectral norm was sufficiently small. As this acted as an amortization that reduces the number of iterations when weight updates are small, this did not result in higher time cost than a fixed number of power iterations, and at the same time, acts as a more reliable guarantee that the Lipschitz is bounded.

Optimization.

For stochastic gradient descent, we used Adam (Kingma and Ba, 2015) with a learning rate of $0.001$ and weight decay of $0.0005$ applied outside the adaptive learning rate computation (Loshchilov and Hutter, 2019; Zhang et al., 2019). We used Polyak averaging (Polyak and Juditsky, 1992) for evaluation with a decay of $0.999$.

Preprocessing.

For density estimation experiments, we used random horizontal flipping for CIFAR-10, CelebA-HQ 64, and CelebA-HQ 256. For CelebA-HQ 64 and 256, we preprocessed the samples to be 5bit. For hybrid modeling and classification experiments, we used random cropping after reflection padding with 4 pixels for SVHN and CIFAR-10; CIFAR-10 also included random horizontal flipping.