Title: LIKELIHOOD CONTRIBUTION BASED MULTI-SCALE ARCHITECTURE FOR GENERATIVE FLOWS

Abstract: Deep generative modeling using flows has gained popularity owing to the tractable exact log-likelihood estimation with efficient training and synthesis process. However, flow models suffer from the challenge of having high dimensional latent space, same in dimension as the input space. An effective solution to the above challenge as proposed by Dinh et al. ( 2016) is a multi-scale architecture, which is based on iterative early factorization of a part of the total dimensions at regular intervals. Prior works on generative flows involving a multi-scale architecture perform the dimension factorization based on a static masking. We propose a novel multi-scale architecture that performs data dependent factorization to decide which dimensions should pass through more flow layers. To facilitate the same, we introduce a heuristic based on the contribution of each dimension to the total log-likelihood which encodes the importance of the dimensions. Our proposed heuristic is readily obtained as part of the flow training process, enabling versatile implementation of our likelihood contribution based multi-scale architecture for generic flow models. We present such implementations for several state-ofthe-art flow models and demonstrate improvements in log-likelihood score and sampling quality on standard image benchmarks. We also conduct ablation studies to compare proposed method with other options for dimension factorization.

1. INTRODUCTION:

Deep Generative Modeling aims to learn the embedded distributions and representations in input (especially unlabelled) data, requiring no/minimal human labelling effort. Learning without knowledge of labels (unsupervised learning) is of increasing importance because of the abundance of unlabelled data and the rich inherent patterns they posses. The representations learnt can then be utilized in a number of downstream tasks such as semi-supervised learning (Kingma et al., 2014; Odena, 2016) , synthetic data augmentation and adversarial training (Cisse et al., 2017) , text analysis and model based control etc. The repository of deep generative modeling majorly includes Likelihood based models such as autoregressive models (Oord et al., 2016b; Graves, 2013) , latent variable models (Kingma & Welling, 2013) , flow based models (Dinh et al., 2014; 2016; Kingma & Dhariwal, 2018) and implicit models such as generative adversarial networks (GANs) (Goodfellow et al., 2014) . Autoregressive models (Salimans et al., 2017; Oord et al., 2016b; a; Chen et al., 2017) achieve exceptional log-likelihood score on many standard datasets, indicative of their power to model the inherent distribution. But, they suffer from slow sampling process, making them unacceptable to adopt in real world applications. Latent variable models such as variational autoencoders (Kingma & Welling, 2013) tend to better capture the global feature representation in data, but do not offer an exact density estimate. Implicit generative models such as GANs which optimize a generator and a discriminator in a min-max fashion have recently become popular for their ability to synthesize realistic data (Karras et al., 2018; Engel et al., 2019) . But, GANs do not offer a latent space suitable for further downstream tasks, nor do they perform density estimation.

Flow based generative models (Dinh et al., 2016; Kingma & Dhariwal, 2018) perform exact density estimation with fast inference and sampling, due to their parallelizability. They also provide an information rich latent space suitable for many applications. However, the dimension of latent space for flow based generative models is same as the high-dimensional input space, by virtue of bijectivity nature of flows. This poses a bottleneck for flow models to scale with increasing input dimensions due to computational complexity. An effective solution to the above challenge is a multi-scale architecture, introduced by Dinh et al. (2016) , which performs iterative early gaussianization of a part of the total dimensions at regular intervals of flow layers. This not only makes the model computational and memory efficient but also aids in distributing the loss function throughout the network for better training. Many prior works including Kingma & Dhariwal (2018) ; Atanov et al. (2019) ; Durkan et al. (2019) ; Kumar et al. (2019) implement multi-scale architecture in their flow models, but use static masking methods for factorization of dimensions. We propose a multi-scale architecture which performs data dependent factorization to decide which dimensions should pass through more flow layers. For the decision making, we introduce a heuristic based on the amount of total log-likelihood contributed by each dimension, which in turn signifies their individual importance. We lay the ground rules for quantitative estimation and qualitative sampling to be satisfied by an ideal factorization method for a multi-scale architecture. Since in the proposed architecture, the heuristic is obtained as part of the flow training process, it can be universally applied to generic flow models. We present such implementations for flow models based on affine/additive coupling and ordinary differential equation (ODE) and achieve quantitative and qualitative improvements. We also perform ablation studies to confirm the novelty of our method. Summing up, the contributions of our research are,

Contributions::

1. A log-determinant based heuristic which entails the contribution by each dimensions towards the total log-likelihood in a multi-scale architecture. 2. A multi-scale architecture based on the above heuristic performing data-dependent splitting of dimensions, implemented for several classes of flow models.

3.. Quantitative and qualitative analysis of above implementations and an ablation study:

To the best of our knowledge, we are the first to propose a data-dependent splitting of dimensions in a multi-scale architecture.

2. BACKGROUND:

In this section, we illustrate the functioning of flow based generative models and the multiscale architecture as introduced by Dinh et al. (2016) .

2.1. FLOW-BASED GENERATIVE MODELS:

Let x be a high-dimensional random vector with unknown true distribution p(x). The following formulation is directly applicable to continous data, and with some pre-processing steps such as dequantization (Uria et al., 2013; Salimans et al., 2017; Ho et al., 2019) to discrete data. Let z be the latent variable with a known standard distribution p(z), such as a standard multivariate gaussian. Using an i.i.d. dataset D, the target is to model p θ (x) with parameters θ. A flow, f θ is defined to be an invertible transformation that maps observed data x to the latent variable z. A flow is invertible, so the inverse function T maps z to x, i.e.

z = f θ (x) = T -1 (x) and x = T (z) = f -1 θ (z)

(1) The log-likelihood can be expressed as,

log (p θ (x)) = log(p(z)) + log det ∂f θ (x) ∂x T (2)

where ∂f θ (x) ∂x T is the Jacobian of f θ at x. The invertibile nature of flow allows it to be capable of being composed of other flows of compatible dimensions. In practice, flows are constructed by composing a series of component flows. Let the flow f θ be composed of K component flows, i.e.

f θ = f θ K • f θ K-1 • • • • • f θ1 and the intermediate variables be denoted by y K , y K-1 , • • • , y 0 = x. Then the log-likelihood of the composed flow is, log (p θ (x)) = log(p(z)) + log det ∂(f θ K • f θ K-1 • • • • • f θ1 (x)) ∂x T (3) = log(p(z))

Log-latent density

EQUATION

which follows from the fact that det(A • B) = det(A) • det(B). In our work, we refer the first term in Equation 4 as log-latent-density and the second term as log-determinant (log-det). The reverse path, from z to x can be written as a composition of inverse flows,

x = f -1 θ (z) = f -1 θ1 • f -1 θ2 • • • • • f -1 θ K (z).

Confirming with the properties of a flow as mentioned above, different types of flows can be constructed (Kingma & Dhariwal, 2018; Dinh et al., 2016; 2014; Behrmann et al., 2018) .

2.2. MULTI-SCALE ARCHITECTURE:

Multi-scale architecture is a design choice for latent space dimensionality reduction of flow models, in which part of the dimensions are factored out/early gaussianized at regular intervals, and the other part is exposed to more flow layers. The process is called dimension factorization. In the problem setting as introduced in Section 2.1, the factoring operation can be mathematically expressed as,

y 0 = x (5) z l+1 , y l+1 = f θ l+1 (y l ), l ∈ {0, 1, • • • , K -2} (6) z K = f θ K (y K-1 ) (7) z = (z 1 , z 2 , • • • , z K ) (8)

The factoring of dimensions at early layers has the benefit of distributing the loss function throughout the network (Dinh et al., 2016) 

3. LIKELIHOOD CONTRIBUTION BASED MULTISCALE ARCHITECTURE:

In a multi-scale architecture, it is apparent that the network will better learn the distribution of variables getting exposed to more layers of flow as compared to the ones which get factored at a finer scale (earlier layer). The method of dimension splitting proposed by prior works such as (Dinh et al., 2016; Kingma & Dhariwal, 2018; Behrmann et al., 2018) are static in nature and do not distinguish between importance of different dimensions. In this section, we introduce a heuristic to estimate the contribution of each dimension towards the total log-likelihood, and introduce a method which can use the heuristic to decide the dimensions to be factored at an earlier layer, eventually achieving preferrential splitting in multiscale architecture. Our approach builds an efficient multiscale architecture which factors the dimensions at each flow layer in a way such that the local variance in the input space is well captured as the flow progresses and the log-likelihood is maximized. We also describe how our multi-scale architecture can be implemented over several standard flow models.

Recall from Equation 4 that the log-likelihood is composed of two terms, the log-latent-density term and the log-det term. The log-latent-density term depends on the choice of latent distribution whereas the log-det term depends on the modeling of the flow layers. So, careful design of flow layers can lead to maximized log-determinant, eventually maximizing the likelihood. The total log-det term is nothing but the sum of log-det terms contributed by each dimension. Let the dimension of the input space x be s × s × c, where s is the image height/width and c is the number of channels for image inputs. For the following formulation, let us assume no dimensions were gaussianized early so that we have access to log-det term for all dimensions at each flow layer, and the dimension at all intermediate layer remains same (i.e. s × s × c). We apply a flow (f θ ) with K component flows to x, z pair, so that z

= f θ (x) = f θ K • f θ K-1 • • • • • f θ1 (x).

The intermediate variables are denoted by y K , y K-1 , • • • , y 0 with y K = z (since no early gaussianization was done) and y 0 = x. The log-det term at layer l, L

d , is given by,

[L (l) d ] scaler = l i=1 log | det(∂y i /∂y T i-1 )| (9)

The log-det of the jacobian term encompasses contribution by all the s × s × c dimensions. We decompose it to obtain the individual contribution by variables (dimensions) towards the total log-det (∼ total log-likelihood). The log-det term can be viewed (with slight abuse of notations) as a s × s × c tensor corresponding to each of the dimensions, summed over the flow layers till l,

EQUATION

EQUATION

The entries in [L

d ] s×s×c having higher value correspond to the variables which contribute more towards the total log-likelihood, hence are more valuable for better flow formulation. So, we can use the likelihood contribution (in the form of log-det term) by each dimension as a heuristic for deciding which variables should be gaussianized early in a multi-scale architecture. Ideally, at each flow layer, the variables with more log-det term should be exposed to more layer of flow and the ones having less log-det term should be factored out. In this manner, selectively more power can be provided to variables which capture meaningful representation (and are more valuable from log-det perspective) to be expressive by being exposed to multiple flow layers. This formulation leads to enhanced density estimation performance. Additionally, for many datasets such as images, the spatial nature should be taken into account while deciding dimensions for early gaussianization. Summarily, at every flow layer, an ideal factorization method should, 1. (Quantitative) For efficient density estimation: Early gaussianize the variables having less log-det and expose the ones having more log-det to more flow layers 2. (Qualitative) For qualitative reconstruction: Capture the local variance over the flow layers, i.e. the dimensions being exposed to more flow layers should contain representative pixel variables from throughout the whole image.

Keeping the above requirements in mind, variants of hybrid techniques for factorization can be implemented for different types of flow models which involve a multi-scale architecture, to improve their density estimation and qualitative performance. The key requirement is availability of log-det contributions per dimension, which can be fulfilled by decomposition of the log-det of the jacobian. We refer to the method as Likelihood Contribution based Multi-scale Architecture (LCMA). The steps of LCMA implementation for flow models is summarized in Algorithm 1. Note that in step 2 of dimension factorization phase in algorithm 1, we group the dimensions having more/less log-det locally and then perform splitting. This preserves the local spatial variation of the image in both parts of the factorization, leveraging both enhanced density estimation as well as qualitative reconstruction.

Another important observation is since the factorization of dimensions does not occur during the training time, and before the actual training starts, the decision of dimensions which get factored at each flow layer is fixed, the change of variables formula can be applied. This allows the use of non-invertible operations (e.g. max and min pooling) for efficient factorization with log-det heuristic.

Step d ] s×s×c ) is computed specifically for corresponding flow models (Refer Section 3.1 and Section 3.2).

2.. Convert [L (l):

d ] s×s×c into a s 2 × s 2 × 4c shaped tensor using local max and min-pooling (= -max-pooling(-input)) operations (Figure 1 ) at each flow layer. 3. Among the 4c channels, one half contains the dimensions having more log-det term compared with its neighbourhood pixel (Black marked in Fig. 1 ), while the other half contains the dimensions having less log-det (White marked in Fig. 1 ). 4. Split the tensor along the channel dimension to two parts. 5. Forward the corresponding dimensions contributing more towards likelihood into more flow layers and early gaussianize the ones contributing less. 6. Repeat steps 1-5 for all the layers with dimensions passed to that layer till the latent space.

Training Phase: The decision of dimensions to be factored at each layer as performed in previous step remains fixed. Finally, the flow model with proposed LCMA is trained.

models. Some flow models offer direct decomposition of jacobian into per-dimension components, whereas for others, an indirect estimation method has to be adopted. We now describe such methods to obtain such individual likelihood contribution of dimensions for flow models based on affine coupling (RealNVP (Dinh et al., 2016) and Glow (Kingma & Dhariwal, 2018)), and flow models involving ordinary differential equation (ODE) based density estimators (i-ResNet (Behrmann et al., 2018) ), all of which involve a multiscale architecture.

3.1. ESTIMATION OF PER-DIMENSION LIKELIHOOD CONTRIBUTION FOR AFFINE COUPLING BASED FLOW MODELS:

RealNVP (Dinh et al., 2016) : For RealNVP with afffine coupling layers, the logarithm of individual diagonal elements of jacobian, summed over layers till layer l provides the per-dimensional likelihood contribution components at layer l.

Glow (Kingma & Dhariwal, 2018): Unlike RealNVP where the log-det terms for each dimension can be expressed as log of corresponding diagonal element of jacobian, Glow contains 1 × 1 convolution blocks having non-diagonal log-det term for channel dimensions, for a s × s × c tensor h given by,

EQUATION

It remains to decompose the log | det(W)| to individual contribution by each channel. As a suitable candidate, singular values of W correspond to the contribution from each channel dimension, so their log value is the individual log-det contribution. So the individual log-det term for channels are obtained by,

EQUATION

where σ i (W) are the singular values of the weight matrix W. For affine blocks in Glow, same method as RealNVP is adopted. 2019) employ variants of ODE based density estimators. We introduce method to find perdimensional likelihood contribution for i-ResNet (Behrmann et al., 2018) , which is a residual network with invertibility and efficient jacobian computation properties. i-ResNet is modelled as a flow F (x), such that z = F (x) = (I + g)(x), where g(x) is the forward propagation function. The log-likelihood expression is written with the log-det of the jacobian is expressed as a power series,

3.2. ESTIMATION OF PER:

ln p x (x) = ln p z (z) + ln | det J F (x)|, ln | det J F (x)| = tr ln I + J g (x) = ∞ k=1 (-1) k+1 tr(J k g ) k

where tr denotes the trace. Due to computational constraints, the power series is computed up to a finite number of iterations with the tr(J k g ) term stochastically approximated by hutchinson's trace estimator, tr(A) = E p(v) v T Av , E[v] = 0 and Cov(v) = I. The component corresponding to each dimension that becomes part of the log-det term is the diagonal element of J k g , so the per-dimension contribution to the likelihood can be approximated as the diagonal elements of J k g , summed over the power series upto a finite number of iterations n. The diagonal elements are obtained with the hutchinson's trace estimator without any extra cost, i.e

. if v = [v 1 , v 2 , • • • , v s×s×c ] T , ∞ k=1 (-1) k+1 tr(J k g ) k = ∞ k=1 (-1) k+1 E p(v) v T J k g v k = ∞ k=1 (-1) k+1 E p(v) (v T J k g )v k

In above equation, (v T J k g ) is the vector-jacobian product which is multiplied again with v. The individual components which are summed when (v T J k g ) is multiplied with v correspond to the diagonal terms in jacobian, over the expectation E p(v) . So those terms are the contribution by the individual dimensions, to the log-likelihood and are expressed as [L (l) d ] s×s×c for use in step 1 of dimension factorization step in LCMA implementation for i-ResNet.

4. RELATED WORK:

Multi-scale architecture and variants have been successful in a number of prior works in deep generative modeling. For invertible neural networks, Finzi et al. (2019) use a keepChannel for selective feed forward of channels analogous to multi-scaling. In the spectrum of generative flow models, multi-scale architecture has been utilized to achieve the dimensionality reduction and enhanced training because of the distribution of loss function in the network (Dinh et al., 2016; Kingma & Dhariwal, 2018) . A variant of multiscale architecture has been utilized to capture local variations in auto-regressive models (Reed et al., 2017) . Among GAN (Goodfellow et al., 2014 ) models, Denton et al. (2015) use a multiscale variant to generate images in a coarse-to-fine manner. For multi-scale architectures in generative flow models, our proposed method performs factorization of dimensions based on their likelihood contribution, which in another sense translates to determining which dimensions are important from density estimation and qualitative reconstruction point of view. Keeping this in mind, we discuss prior works on generative flow models which involve multi-scaling and/or incorporate permutation among dimensions to capture their interactions.

A number of generative flow models implement a multi-scale architecture, such as Dinh et al. ( 2016 2018) introduce an 1 × 1 convolution layer in between the actnorm and affine coupling layer in their flow architecture. The 1 × 1 convolution is a generalization of permutation operation which ensures that each dimension can affect every other dimension. This can be interpreted as redistributing the contribution of dimensions to total likelihood among the whole space of dimensions. So Kingma & Dhariwal (2018) treat the dimensions as equiprobable for factorization in their implementation of multi-scale architecture, and split the tensor at each flow layer evenly along the channel dimension. We, on the other hand, take the next step and focus on the individuality of dimensions and their importance from the amount they contribute towards the total log-likelihood. The log-det score is available via direct/indirect decomposition of the jacobian obtained as part of computations in a flow training, so we essentially have a heuristic for free. Since our method focuses individually on the dimensions using a heuristic which is always available, it can prove to be have more versatility in being compatible with generic multi-scale architectures. Hoogeboom et al. (2019) extend the concept of 1 × 1 convolutions to invertible d × d convolutions, but do not discuss about multi-scaling. Dinh et al. (2016) also include a type of permutation which is equivalent to reversing the ordering of the channels, but is more restrictive and fixed. Flow models such as Behrmann et al. ( 2018 

5. EXPERIMENTS:

In Section 3, we established that our proposed likelihood contribution based factorization of dimensions can be implemented for flow models involving a multi-scale architecture, in order to improve their density estimation and qualitative performance. In this section we present the detailed results of proposed LCMA adopted for the flow model of RealNVP (Dinh et al., 2016) and quantitative comparisons with Glow (Kingma & Dhariwal, 2018) and i-ResNet (Behrmann et al., 2018) . For direct comparison, all the experimental settings such as data pre-processing, optimizer parameters as well as flow architectural details (coupling layers, residual blocks) are kept the same, except that the factorization of dimensions at each flow layer is performed according to the methods described in Section 3. For ease of access, we also have summarized the experimental details in Appendix A.

For RealNVP, we perform experiments on four benchmarked image datasets: CIFAR-10 ( Krizhevsky, 2009) , Imagenet (Russakovsky et al., 2014) (downsampled to 32 × 32 and 64 × 64), and CelebFaces Attributes (CelebA) (Liu et al., 2015) . The scaling in LCMA is performed once for CIFAR-10, thrice for Imagenet 32 × 32 and 4 times for Imagenet 64 × 64 and CelebA. We compare LCMA with conventional RealNVP and report the quantitative and qualitative results. For Glow and i-ResNet with LCMA, we perform experiments on CIFAR-10 and present improvements over baseline bits/dim. We also perform an ablation studies for LCMA vs. other possible dimension splitting options.

5.1. QUANTITATIVE COMPARISON:

The bits/dim scores of RealNVP with conventional multi-scale architecture (as introduced in Dinh et al. ( 2016)) and RealNVP with LCMA are given in Table 1 . It can be observed that the density estimation results using LCMA is in all cases better in comparison to the baseline. We observed that the improvement for CelebA is relatively high as compared to natural image datasets. This observation was expected as facial features often contain high redundancy and the flow model learns to put more importance (reflected in terms of high log-det) on selected dimensions that define the facial features. Our proposed LCMA exposes such dimensions to more flow layers, making them more expressive and hence the significant improvement in code length (bits/dim) is observed. The improvement in bits/dim is less for natural image datasets because of the high variance among features defining them, which has been the challenge with image compression algorithms. Note that the improvement in density estimation is always relative to the original flow architecture (RealNVP in our case) over which we use our proposed LCMA, as we do not alter any architecture other than the dimension factorization method. The quantitative results of LCMA implementation for RealNVP, Glow and i-ResNet with CIFAR-10 dataset is summarized in Table 2 . The density estimation scores for flows with LCMA outperform the same flow with conventional multi-scale architectures. We performed ablation studies to compare LCMA with other methods for dimension factorization in a multi-scale architecture. We consider 4 variants for our study, namely fixed random permutation (Case 1), multiscale architecture with early gaussianization of high log-det dimensions (Case 2), factorization method with checker-board and channel splitting as introduced in RealNVP (Case 3) and multiscale architecture with early gaussianization of low log-det dimensions, which is our proposed LCMA (Case 4). In fixed random permutation, we randomly partition the tensor into two halves, with no regard to the spatiality or log-det score. In case 2, we do the reverse of LCMA, and gaussianize the high log-det variables early. The bits/dim score and generated samples for each of the method are given in Table 3 . As expected from an information theoretic perspective, gaussianizing high log-det variables early provides the worst density estimation, as the model could not capture the high amount of important information. Comparing the same with fixed random permutation, the latter has better score as the probability of a high log-det variable being gaussianized early reduces to half, and it gets further reduced with RealNVP due to channel-wise and checkerboard splitting. LCMA has the best score among all methods, as the variables carrying more information are exposed to more flow layers. Fixed random permutation has the worst quality of sampled images, as the spatiality is lost during factorization. The sample quality improves for Case 2 and RealNVP. The sampled images are perceptually best for LCMA. Summarizing, LCMA outperforms multi-scale architectures based on other factorization methods, as it improves density estimation and generates qualitative samples.

6. CONCLUSIONS:

We proposed a novel multi-scale architecture for generative flows which employs a data-dependent splitting based the individual contribution of dimensions to the total log-likelihood. Implementations of the proposed method for several state-of-the-art flow models such as RealNVP (Dinh et al., 2016 ), Glow(Kingma & Dhariwal, 2018) and i-ResNet (Behrmann et al., 2018) were presented. Empirical studies conducted on benchmark image datasets validate the strength of our proposed method, which improves log-likelihood scores and is able to generate qualitative samples. Ablation study results confirm the power of LCMA over other options for dimension factorization. 

:



Figures and Tables:

Figure 1: Likelihood contribution based squeezing operation for RealNVP: (On left) The tensor [L (l) d ] s×s×c representing log-det of variables in a flow layer. (On right) It is squeezed to s 2 × s 2 × 4c with local max and min pooling operation. The black (respectively white) marked pixels represent dimensions having more (respectively less) log-det locally.

1 of dimension factorization phase requires computation of individual contribution of dimensions ([L (l) d ] s×s×c ) towards the total log-likelihood, which can vary depending on the original design of flow Algorithm 1: LCMA implementation for generative flow models Pre-Training Phase: Pre-train a network with no multiscale architecture (no dimensionality reduction) to obtain the log-det term at every flow layer. Dimension Factorization: In this phase, the dimensions to be factored at each flow layer is decided based on the log-det term at that layer 1. The individual contribution of dimensions towards likelihood ([L(l)

-DIMENSION LIKELIHOOD CONTRIBUTION FOR FLOW MODELS WITH ODE BASED DENSITY ESTIMATORS Recent works on flow models such as Behrmann et al. (2018); Grathwohl et al. (2018); Chen et al. (

); Kingma & Dhariwal (2018); Atanov et al. (2019); Izmailov et al. (2019); Durkan et al. (2019); Kumar et al. (2019); Behrmann et al. (2018) etc. Kingma & Dhariwal (

); Grathwohl et al. (2018); Chen et al. (2019) involve ODE based density estimators. They also implement a multi-scale architecture, but the splitting operation is a static channel wise splitting without considering importance of individual dimensions or any permutations. Izmailov et al. (2019); Durkan et al. (2019); Kumar et al. (2019); Atanov et al. (2019) use multi-scale architecture in their flow models, coherent with Dinh et al. (2016); Kingma & Dhariwal (2018), but perform the factorization of dimensions without any consideration of the individual contribution of the dimension towards the total log-likelihood. For qualitative sampling along with efficient density estimation, we also propose that factorization methods should preserve spatiality of the image in the two splits, motivated by the spatial nature of splitting methods in Kingma & Dhariwal (2018) (channel-wise splitting) and Dinh et al. (2016) (checkerboard and channel-wise splitting).

Figure 2(a) shows samples from original datasets, Figure 2(b) shows the samples from trained RealNVP flow model with conventional multi-scale architecture and Figure 2(c) shows the samples from RealNVP with LCMA trained on various datasets. The finer facial details such as hair styles, eye-lining and facial folds in Celeba samples generated from RealNVP with LCMA were perceptually better than the baseline. The global feature representation observed is similar to that in RealNVP, as the flow architecture was kept the same. The background for natural images such as Imagenet 32 × 32 and 64 × 64 was constructed at par with the original flow model. As has been observed in different flow models such as RealNVP and Glow, the latent space holds knowledge about the feature representation in the data. We performed linear interpolations in latent space to ensure its efficient construction and generated images, as shown in Figure 3. The interpolations observed were smooth, with intermediate samples perceptibly resembling synthetic faces, signifying the efficient construction of latent space. More interpolations are included in Appendix B.

Figure 2: Samples from RealNVP (Dinh et al., 2016) and RealNVP flow model with proposed likelihood contribution based multiscale architecture (LCMA) trained on different datasets. The datasets shown in this figure are in order: CIFAR-10, Imagenet(32 × 32), Imagenet (64 × 64) and CelebA (without low-temperature sampling). Additional samples are included in Appendix C.

Figure 3: Smooth linear interpolations in latent space between two images from CelebA dataset (without low-temperature sampling). The intermediate samples perceptibly resemble synthetic faces.

Figure 7: Samples from model trained on Imagenet 64 × 64 dataset

Improvements in density estimation (in bits/dim) using proposed method for RealNVP

Table content: <table><tr><td>Model</td><td colspan="2">CelebA CIFAR-10</td><td>ImageNet</td><td>ImageNet</td></tr><tr><td/><td/><td/><td>32x32</td><td>64x64</td></tr><tr><td>RealNVP (Dinh et al., 2016)</td><td>3.02</td><td>3.49</td><td>4.28</td><td>3.98</td></tr><tr><td>RealNVP flow model with Likelihood</td><td>2.71</td><td>3.43</td><td>4.21</td><td>3.92</td></tr><tr><td>Contribution based Multiscale Architecture (ours)</td><td/><td/><td/><td/></tr></table>

Density estimation results (in bits/dim) for RealNVP, Glow and i-ResNet with LCMA trained on CIFAR-10. * Model for i-ResNet has not fully converged An ideal dimension factorization method should capture the local variance over series of flow layers, which helps in qualitative sampling. For LCMA implementation, we introduced local max and min pooling operations on log-det heuristic to decide which dimensions to be gaussianized early (Section 3).

Table content: <table><tr><td>Type of multi-scale architecture</td><td>RealNVP</td><td>Glow</td><td>i-ResNet</td></tr><tr><td>Conventional Multi-scale Architecture</td><td>3.49</td><td>3.35</td><td>3.45</td></tr><tr><td>Likelihood Contribution based Multi-scale Architecture</td><td>3.43</td><td>3.31</td><td>3.40  *</td></tr><tr><td>5.2 QUALITATIVE COMPARISON</td><td/><td/><td/></tr></table>

Ablation study results for multi-scale architectures with various factorization methods

Table content: <table><tr><td>Evaluations</td><td>Fixed Random Permutation</td><td>Multiscale architecture with early gaussianization of high log-det dimensions</td><td>RealNVP (Dinh et al., 2016)</td><td>Multiscale architecture with early gaussianization of low log-det dimensions</td></tr><tr><td>Quantitative</td><td>3.05</td><td>3.10</td><td>3.02</td><td>2.71</td></tr><tr><td>Evaluation (Bits/dim)</td><td/><td/><td/><td/></tr><tr><td>Qualitative</td><td/><td/><td/><td/></tr><tr><td>Evaluation</td><td/><td/><td/><td/></tr></table>

Peer review (iclr2020):
Summary: The paper investigates a strategy for factoring out dimensions in multi-scale generative flow models. The strategy relies on a heuristic that employs the availability of per-dimension log-determinant terms (e.g. as affine couplings) to decide which half of the dimensions to factor out. Quantitative experimental results support the proposed strategy’s efficacy. Recommendation: Weak Reject The paper misses several important comparisons and baselines - both in terms of placing the proposed method in a broader context (e.g. how could the method be used in multiscale i-ResNet), as well as providing experimental comparisons that would definitively demonstrate the method’s contribution (e.g. is it the heuristic dimension splitting or the unfactored pre-training that provides the benefit. The applicability of the proposed method appears to be overstated. The paper suggests that the method is applicable to any multi-scale flow architecture. However, it depends on the availability of per-dimension log-determinants. As the paper states, these values are readily available for methods that rely on affine couplings (e.g. RealNVP, Glow), but not for methods such as i-ResNets or FFJORD, that also employ multi-scale architectures to factor out variables. Major comments: 1. Section 2.1 introduces flows as a mapping from data x to the latent code z, and gives the log-likelihood formula (2) that can be optimized during model training. This presentation is at odds with Section 3, where the authors talk about sampling a latent variable that fixes the “log-latent density” and only leaves the log-determinant term to be optimized (e.g. “[...] the log-latent-density term depends on the choice of the latent distribution and if fixed given the sampled latent variable. [...] once the variable is sampled, maximizing the log-det term results in maximized likelihood.” The two presentations are at odds with each other and should be reconciled, ideally by altering Section 3 since it does not reflect the way flow models are trained. 2. The authors made an implicit assumption that the log-det term is decomposable into per-dimension component. As mentioned earlier in this review, generally speaking this is not true and methods such as i-ResNets or FFJORD do not (directly?) permit such decomposition, while they do employ multi-scale architectures akin to that of RealNVP. This assumption manifests itself in several places in the paper, which are listed below. Either the authors could make this assumption and the limitations imposed by it very clear, or they could provide additional information on how their method extends to methods that do not provide per-dimension log-det contributions. a) In Section 3 “The total log-det term is nothing by the sum of log-det terms for contributed by each dimension”. This is obvious (and possibly holds) only for affine couplings. b) In Section 3 “Nevertheless, such an analogy can be extended for other flow models which involve a multiscale architecture [...]”. As mentioned, I am not convinced this is true. c) In Section 4 “Since our method focuses individually on the dimensions using a heuristic which is always available in flow model training, it can prove to be have more versatility in being compatible with generic multi-scale architecture”. Same as above - in fact I believe that the opposite may be true. d) Section 4 does not mention methods that employ multi-scale architectures whil not allowing for discerning per-dimension contributions of the log-det. Mentioning these methods is important for accurately positioning the authors contribution relative to the existing literature. e) The method is only applied to the RealNVP architecture. The claim of it being generally applicable to multi-scale architectures would be much stronger if the comparison would include other multi-scale architectures. Here, I strongly recommend i-ResNets or a similar architecture based on log-det approximation to the entire coupling layer. 3. Unless I missed it, the authors do not mention how they aggregate the log-det values. They are available per datapoint. Are they aggregated over the entire dataset? 4. In Section 4 the authors imply that the contribution of a dimension towards the total likelihood is dominated by the log determinant (“[...] as the contribution by the variable (dimension) towards the total log-det (~ total log-likelihood)”). This is not obvious, and I am not sure it is always true - it probably depends on the choice of the base distribution p(z). 5. The authors show experimentally that the use of their variable factorisation heuristic improves log-likelihoods over the baseline RealNVP model; they further perform ablation studies to confirm that preferential factorisation of low log-det dimensions provides best log-likelihoods and qualitative results on the CelebA dataset. However, several points remain unclear. a) What are the relative contributions of pre-training without dimension factorisation and the proposed factorisation heuristic? Do the experiments shown in Table 2 all employ the pre-training scheme? If so, this should be clearly stated. If not, this set of experiments should be performed. b) The networks used in the experiments use between m=1 and 4 factorisation layers. So in total, there are 2^m possible decisions of which half of the variables at those layers to factorise. These numbers are not so large as to prevent us from training all possible combinations of the networks. How does the proposed heuristic compare to just training all (or a few sampled) factorisations decided a priori? This comparison should also investigate the effect of using pre-training. 6. In the qualitative comparison (Section 5.2) the authors argue two points (i) RealNVP with the proposed method generates finer details on CelebA; and (ii) provides a reasonable latent space that can be interpolated in. a) With regards to (i), I personally find it difficult to argue about fine details in what are effectively low-resolution images. The differences (which are already hard to see and easy to imagine) could be present due to minute changes in the training code/procedure/random seed/etc. I would be more confident about these differences if the authors could confirm that the methods were trained using the same code base, random seeds, dataset shuffle and framework versions. b) How do the qualitative interpolation results compare to RealNVP without the proposed factorisation heuristic? Minor comments: - In Section 2.1 “Let x be a high-dimensional random vector with unknown true distribution x ~ p(x) [...]”. Here x appears to refer to the data or a sample from the data distribution, and not just a random vector. This could be made clearer. - In Section 2.1 the “jacobian” should be written with a capital “J” - In Section 2.1 and elsewhere, when denoting outputs of intermediate flows f_i as y_i, it is mentioned that y_0 = x, but not that y_k = z. If the latter is true, mentioning this would improve clarity. - Section 3 “In a multi-scale architecture, it is apparent that the variables getting exposed to more layers of flow will be more expressive in nature [...]”. I do not find this to be an obvious fact. Perhaps the authors could provide an intuition for why this is true or demonstrate this on a toy example? My confusion may stem from the fact that I am unsure what it means for a variable (i.e. a dimension we factor out) to be more expressive. - Some phrasing is a little unusual (e.g. “less (more) log-det tems” instead of “smaller (larger) log-det term”; “to be have”). - In Section 5.1 “code length” is introduced without context. The connection between code length, log-likelihood and compression can be made more clear. ------------------------------------------------ Post rebuttal update ------------------------------------------------ I’d like to thank the authors for additional elaboration on their baseline experiments that consider their heuristic-based scheme for factoring out dimensions (the low-low-low scheme) and the “anti-heuristic” (which considers the high-high-high scheme). I agree with the authors that both schemes would have been within the 2^m possibilities I encourage them to consider, however I do not fully agree with some of the conclusions the authors draw for these experiments. First, given that the method proposed by the authors is a heuristic, it is not obvious that the high-high-high and the low-low-low schemes indeed correspond the worst and best possible of the 2^m schemes. Running the 2^m experiments could demonstrate this empirically and strengthen the manuscript. Second, if we speak about the high-high-high and low-low-low factorizations, then we’ve already gone through the computationally expensive effort of pre-training a model that does not factor out any variables. It is precisely because of this that I’d like to see a baseline that doesn’t do any pre-training, but simply enumerates the 2^m schemes and selects the one with the best validation score. It is not obvious that this approach would computationally more expensive than the pre-training step -- another point I believe is important to cover. To summarize, I do not believe that the baselines currently present in the paper are a substitute for the ones requested. Including new results requires a review of those new results, so I would not be in favour of adding new results at the camera ready stage. I therefore retain my score.