Year: 2019

Abstract:
We investigate a variant of variational autoencoders where there is a superstructure of discrete latent variables on top of the latent features. In general, our superstructure is a tree structure of multiple super latent variables and it is automatically learned from data. When there is only one latent variable in the superstructure, our model reduces to one that assumes the latent features to be generated from a Gaussian mixture model. We call our model the latent tree variational autoencoder (LTVAE). Whereas previous deep learning methods for clustering produce only one partition of data, LTVAE produces multiple partitions of data, each being given by one super latent variable. This is desirable because high dimensional data usually have many different natural facets and can be meaningfully partitioned in multiple ways.

text: We investigate a variant of variational autoencoders where there is a superstructure of discrete latent variables on top of the latent features. In general, our superstructure is a tree structure of multiple super latent variables and it is automatically learned from data. When there is only one latent variable in the superstructure, our model reduces to one that assumes the latent features to be generated from a Gaussian mixture model. We call our model the latent tree variational autoencoder (LTVAE). Whereas previous deep learning methods for clustering produce only one partition of data, LTVAE produces multiple partitions of data, each being given by one super latent variable. This is desirable because high dimensional data usually have many different natural facets and can be meaningfully partitioned in multiple ways.

heading: 1 INTRODUCTION
text: Clustering is a fundamental task in unsupervised machine learning, and it is central to many datadriven application domains. Cluster analysis partitions all the data into disjoint groups, and one can understand the structure of the data by examining examples in each group. Many clustering methods have been proposed in the literature (Aggarwal & Reddy, 2013), such as k-means (MacQueen et al., 1967), Gaussian mixture models (Christopher, 2016) and spectral clustering (Von Luxburg, 2007). Conventional clustering methods are generally applied directly on the original data space. However, it is challenging to perform cluster analysis on high dimensional and unstructured data (Steinbach et al., 2004), such as images. It is not only because the dimensionality is high, but also because the original data space is too complex to interpret, e.g. there are semantic gaps between pixel values and objects in images.
Recently, deep learning based clustering methods have been proposed that simultanously learn nonlinear embeddings through deep neural networks and perform cluster analysis on the embedding space. The representation learning process learns effective high-level representations from high dimensional data and helps the cluster analysis. This is typically achieved by unsupervised deep learning methods, such as restricted Boltzmann machine (RBM) (Hinton et al., 2006; Hinton & Salakhutdinov, 2006), autoencoders (AE) (Vincent et al., 2008; 2010), variational autoencoders (VAE) (Kingma & Welling, 2014), etc. Previous deep learning based clustering methods (Xie et al., 2016; Guo et al., 2017; Jiang et al., 2017; Yang et al., 2017) assume one single partition over the data and that all attributes define that partition. In real-world applications, however, the assumptions are usually not true. High-dimensional data are often multifaceted and can be meaningfully partitioned in multiple ways based on subsets of attributes (Chen et al., 2012). For example, a student population can be clustered in one way based on course grades and in another way based on extracurricular activities. Movie reviews can be clustered based on both sentiment (positive or negative) and genre (comedy, action, war, etc.). It is challenging to discover the multi-facet structures of data, especially for high-dimensional data.
To resolve the above issues, we propose an unsupervised learning method, latent tree variational autoencoder (LTVAE) to learn latent superstructures in variational autoencoders, and simultaneously perform representation learning and structure learning. LTVAE is a generative model, where the data is assumed to be generated from latent features through neural networks, while the latent features themselves are generated from tree-structured Bayesian networks with another level of latent variables as shown in Fig. 1. Each of those latent variables defines a facet of clustering. The proposed method automatically selects subsets of latent features for each facet, and learns the dependency structure among different facets. This is achieved through systematic structure learning. Consequently, LTVAE is able to discover complex structures of data rather than one partition. We also propose efficient learning algorithms for LTVAE with gradient descent and Stepwise EM through message passing.
The rest of the paper is organized as follows. The related works are reviewed in Section 2. We introduce the proposed method and learning algorithms in Section 3. In Section 4, we present the empirical results. The conclusion is given in Section 5.

heading: 2 RELATED WORKS
text: Clustering has been extensively studied in the literature in many aspects (Aggarwal & Reddy, 2013). More complex clustering methods related to structure learning using Bayesian nonparametrics have been proposed, like Dirichlet Process (Blei et al., 2006), Hierarchical Dirichlet Process (HDP) (Teh et al., 2006). However, those are with conventional clustering methods that apply on raw data. Recently, deep learning based clustering methods have drawn more and more attention. A simple two-stage approach is to first learn low-dimensional embeddings using unsupervised feature learning methods, and then perform cluster analysis on the embeddings. However, without any supervision, the representation learning do not necessarily reveal the true cluster structure of the data. DEC (Xie et al., 2016) is a method that simultaneously learns feature representations and cluster assignments through deep autoencoders. It gradually improves the clustering by driving the deep network to learn a better mapping. Improved Deep Embedded Clustering (Guo et al., 2017) improves DEC by keeping the decoder network and adding reconstruction loss to the original clustering loss in DEC. Variational deep embedding (Jiang et al., 2017) is a generative method that models the data generative process using a Gaussian mixture model combined with a VAE, and also performs joint learning of representations and clustering. Similarly, GMVAE (Dilokthanakul et al., 2016) performs joint learning of a GMM and a VAE, but instead generates the mixture components through neural networks. Deep clustering network (DCN) (Yang et al., 2017) is another one that jointly learns an autoencoder and performs k-means clustering. These joint learning methods consistently achieve better clustering results than conventional ones. The method proposed in (Yang et al., 2016) uses convolutional neural networks and jointly learns the representations and clustering in a recurrent framework. All these methods assume flat partitions over the data, and do not attempt the structure learning issue. An exception is hierarchical nonparametric variational autoencoders proposed in (Goyal et al., 2017). It uses nCRP as the prior for VAE to allow infinitely deep and branching tree hierarchy structure and focuses on learning hierarchy of concepts. However, it is still one partition over the data, only that the partitions in upper levels are more general partitions, while those in lower levels more fine-grained. Different from it, our work focuses on multifacets of clustering, for example, the model could make one partition based on identity of subjects, while another partition based on pose.

heading: 3 THE PROPOSED METHOD
text: In this section, we present the proposed latent tree variational autoencoder and the learning algorithms for joint representation learning and structure learning for multidimensional clustering.

heading: 3.1 LATENT TREE VARIATIONAL AUTOENCODER
text: Deep generative models assume that data x is generated from latent continuous variable z through some random process. The process consists of two steps: (1) a value z is generated from some prior distribution p(z); (2) the observation x is generated from the conditional distribution pθ(x|z), which is parameterized through deep neural networks. Thus, it defines the joint distribution between
𝑍"
𝑌" 𝑌$
𝑍$ 𝑍", 𝑌" 𝑍&, 𝑌"
𝑌", 𝑌$
𝑍', 𝑌$
𝑃(𝑍"|𝑌") 𝑃(𝑍$|𝑌") 𝑃(𝑍&|𝑌$)
𝑃(𝑌$|𝑌")𝑃(𝑌")
𝑃(𝑍" = 𝑧"|𝑌") 𝑃(𝑍& = 𝑧&|𝑌")𝑃(𝑍' = 𝑧'|𝑌$)
𝑃(𝑌$|𝑌")𝑃(𝑌")
Clique Tree
𝑍& 𝑍'
𝑃(𝑍'|𝑌$)
𝑍$, 𝑌"
𝑃(𝑍" = 𝑧"|𝑌")
Figure 2: Inference and gradient through message passing. Solid-arrows denote collecting message, and dashed-arrows denote distributing message.
observation x and latent variable z:
p(x, z) = p(z)pθ(x|z) (1) This process is hidden from our view, and we learn this process by maximizing the marginal loglikelihood p(x) over the parameters θ and latent variable z from data. After the learning, the latent variable z can be regarded as the deep representations of x since it captures the most relevant information of x. Thus, the learning process is also called representation learning.
In order to learn the latent structure of z, for example multidimensional cluster structure, we introduce a set of latent variables Y1, ..., Yl on top of z. A single z or multiple z’s form a node zb. Suppose variables in z form B nodes of z1, · · · , zB . Each latent variable Y may be only connected to a subset of nodes, and the dependency of each zb and its parent Y is characterized by a conditional Gaussian distribution. Furthermore, the latent variables Y1, ..., Yl are connected to each other, and the dependency of a latent variable Y on its parent Y ′ is characterized by a conditional distribution P (Y |Y ′). This essentially forms a Bayesian network. And if we restrict the network to be treestructured, the z and Y together form a latent tree model (Zhang, 2004; Poon et al., 2010; 2013; Mourad et al., 2013; Pearl, 2014; Zhang & Poon, 2017) with z being the observed variables and Y being the latent variables. For multidimensional clustering, each latent variable Y is taken to be a discrete variable, where each discrete state y of Y defines a cluster. Each latent variable Y thus defines a facet partition over the data based on subset of attributes and multiple Y ’s define multiple facets. Given a value y of Y , zb follows a conditional Gaussian distribution P (zb|y) = N (µy,Σy) with mean vector µy and covariance matrix Σy . Thus, each zb and its parent constitute a Gaussian mixture model (GMM). Suppose the parent of a node is denoted as π(·), the maginal distribution of z is defined as follows
p(z) = ∑ Y l∏ j=1 p(yj |π(Yj)) B∏ b=1 N (zb|µπ(zb),Σπ(zb)), (2)
which sums over all possible combinations of Y states. As a matter of fact, a GMM is a Gaussian LTM that has only one latent variable connecting to all observed variables.
Let the latent structure of Y be S, defining the number of latent variables in Y, the number of discrete states in each variable Y and the connectivity structure among all variables in z and Y. And let the parameters for all conditional probabilities in the latent structure be Θ. Both the latent structure S and the latent parameters Θ are unknown. We aim to jointly learn data representations and the latent structure. The proposed LTVAE model is shown in Fig. 1. The latent structure S are automatically learned from data and will be discussed in a later section.
Due to the existence of the generation network, the inference of the model is intratable. Instead, we do amortized variational inference for the latent variable z by introducing an inference network (Kingma & Welling, 2014) and define an approximate posterior qφ(z|x). The evidence lower bound (ELBO) LELBO of the marginal loglikelihood of the data given (S,Θ) is:
LELBO(x) = Eqφ(z|x)[log pθ(x|z)] + Eqφ(z|x)[log ∑ y pS(z,y; Θ)] + H[qφ(z|x)], (3)
where log ∑
y pS(z,y; Θ) is the marginal loglikelihood of the latent variable z under the latent tree model, and H[·] is the entropy. The conditional generative distribution pθ(x|z) could be a Gaussian distribution if the input data is real-valued, or a Bernoulli distribution if binary, parameterized by the generation network. Using Monte Carlo sampling, the ELBO can be asymptotically estimated by
LELBO(x) ' 1
M M∑ i=1 log pθ(x|z(i)) + log ∑ y pS(z (i),y; Θ) + H[qφ(z|x)], (4)
where z(i) ∼ qφ(z|x). The term H[qφ(z|x)] can be computed analytically if we choose the form of qφ(z|x) to be a Gaussian distributionN (z;µx, σx): H[qφ(z|x)] = J2 log(2π)+ 1 2 ∑J j=1(1+log σ 2 j ), where J is the dimensionality of z.
Furthermore, the marginal loglikelihood log ∑
y pS(z (i),y; Θ) can be computed efficiently through
message passing. Message passing is an efficient algorithm for inference in Bayesian networks (Koller & Friedman, 2009; Poon et al., 2013). In message passing, we first build a clique tree using the factors in the defined probability density. Because of the tree structure, each zb along with its parent form a clique with the potential ψ(zb, y) being the corresponding conditional distribution. This is illustrated in Fig. 2. With the sampled z(i), we can compute the message ψ′(y) by absorbing the evidence from z. During collecting message phase, the message ψ′(y) are sent towards the pivot. After receiving all messages, the pivot distributes back messages towards all z. Both the posterior of Y and the marginal loglikelihood of z(i) thus can be computed in the final normalization step.

heading: 3.2 PARAMETER LEARNING THROUGH GRADIENT DESCENT AND STEPWISE EM WITH MESSAGE PASSING
text: In this section, we propose efficient learning algorithms for LTVAE through gradient descent and stepwise EM with message passing.
Given the latent tree model (S,Θ), the parameters of neural networks can be efficiently optimized through stochastic gradient descent (SGD). However, in order to learn the model, it is important to efficiently compute the gradient of the marginal loglikelihood log pS(z; Θ) from the latent tree model, the third term in Eq. 4. Here, we propose an efficient method to compute gradient through message passing. Let zb be the variables that we want to compute gradient with respect to, and let Yb be the parent node. The marginal loglikelihood of full z can be written as
log pS(z; Θ) = log[ ∑ yb N (zb|µyb ,Σyb)f(yb)], (5)
where f(yb) is the collection of all the rest of the terms not containing zb. The gradient gzb of the marginal loglikelihood log pS(z; Θ) w.r.t zb thus can be computed as
gzb = 1
pS(z; Θ)
∂ ∑ yb f(yb)N (zb|µyb ,Σyb)
∂zb = ∑ yb p(yb|z) ∂ log[f(yb)N (zb|µyb ,Σyb)] ∂zb
= ∑ yb p(yb|z)Σ−1yb (µyb − zb) (6)
where p(yb|z) is the posterior probability of yb and can be computed efficiently with message passing as described in the previous section. The detailed derivation is in Appendix E. Since z = [z1, ..., zB ], we have
∂ log p(z)
∂z =
[ ∂ log p(z)
∂z1 , ...,
∂ log p(z)
∂zB
] = [gz1 , ...,gzB ] . (7)
With the efficient computation of the third term in Eq. 4 and its gradient w.r.t z through message passing, the parameters of inference network and generation network can be efficiently optimized through SGD.
In order to jointly learn the parameters of the latent tree Θ, we propose Stepwise EM algorithm based on mini-batch of data. Specifically, we maximize the third term in Eq. 4, i.e. the marginal loglikelihood of z under the latent tree. In the Stepwise E-step, we compute the distributions P (y, y′|z, θ(t−1)) and P (y|z, θ(t−1)) for each latent node Y and its parent Y ′. In the Stepwise
M-step, we estimate the new parameter θ(t). Let s(z,y) be a vector the sufficient statistics for a single data case. Let s̄ = EpS(y|z;Θ)[s(z,y)] be the expected sufficient statistics for the data case, where the expectation is w.r.t the posterior distribution of y with current parameter. And let µ = ∑N i=1 s̄i be the sum of the expected sufficient statistics. The update of the parameter Θ is performed as follows: s̄ti = EpS(yi|zi;Θt)[s(zi,yi)]
µt+1 = µt + η(s̄ti − µt) Θt+1 = arg max
Θ l(µt+1,Θ),
(8)
where η is the learning rate and l is the complete data loglikelihood. Each iteration of update of LTVAE thus is composed of one iteration of gradient descent update for the neural network parameters and one iteration of Stepwise EM update for the latent tree model parameters with a mini-batch of data.

heading: 3.3 STRUCTURE LEARNING
text: For the latent structure S, there are four aspects need to determine: the number of latent variables, the cardinalities of latent variables, the connectivities among variables. We aim at finding the model m∗ that maximizes the BIC score (Schwarz et al., 1978; Koller & Friedman, 2009):
BIC(m|D) = logP (D|m, θ∗)− d(m) 2 logN,
where θ∗ is the MLE of the parameters and d(m) is the number of independent parameters. The first term is known as the likelihood term. It favors models that fit data well. The second term is known as the penalty term. It discourages complex models. Hence, the BIC score provides a tradeoff between model fit and model complexity. To this end, we perform systematic searching to find a structure with a high BIC score. We use the hill-climing algorithm to search for m∗ as in (Poon et al., 2010; 2013), and define 7 search operators: node introduction (NI) and node deletion (ND) to introduce new latent nodes and delete existing nodes, state introduction (SI) and state deletion (SD) to add a new state and delete a state for existing nodes, node relocation (NR) to change links of existing nodes, pouching (PO) and unpouching (UP) operators to combine nodes into a single node and separate variables from a node.. The structure search operators are shown in Fig. 3. Each operator produces a set of candidates from existing structure, and the best candidate is picked if it improves the previous one. To reduce the number of possible search candidates, we first perform SI, NI and PO to expand the structure and pick the best model. Then we perform NR to adjust the best model. Finally, we perform UP, ND and SD to simplify the current best structure and pick the best one. Acceleration techniques (Poon et al., 2013) are adopted that make the algorithm efficient enough. The structure learning is performed iteratively together with the parameter learning of neural networks.
The overall learning algorithm is illustrated in Algorithm 1. Starting from a pretrained model, we iteratively improve the structure and parameters of latent tree model while learning the representations of data through neural network in a greedy manner. Using current structure St as the initial structure,
Algorithm 1 Learning Latent Tree Variational Autoencoder Input: data D, z dim, neural networks, E θ, φ,S0,Θ0 ← pretrain(D) repeat
for e = 1 to E do for each minibatch X in D do
Compute qφ(z|µx, σx) Sample z(i) ∼ q(z|µx, σx) Compute log pS(z; Θ) and ∂ log pS(z)∂z from Eq. 5 and 7 Compute ELBO from Eq. 4 θ, φ← Back-propagation and SGD step Θ← StepwiseEM(z(i))
end for end for Dz ← µD repeat S∗,Θ∗ ← SearchWith(St−1,Θt−1, {SI, NI, PO}) S∗,Θ∗ ← SearchWith(S∗,Θ∗ {NR}) St,Θt ← SearchWith(S∗,Θ∗, {UP, ND, SD})
until BIC(St,Θt|Dz) ≤ BIC(St−1,Θt−1|Dz) until stopping criteria return θ, φ,S,Θ
we search for a better model. With new latent tree model, we optimize for a better representation until convergence.

heading: 4 EXPERIMENTS

heading: 4.1 SYNTHETIC-DATA DEMONSTRATION
text: We first demonstrate the effectiveness of the proposed method through synthetic data. Assume that the data points have two facets Y1 and Y2, where each facet controlls a subset of attributes (e.g. two-dimensional domain) and defines one partition over the data. This four-dimensional domain z = {z1, z2, z3, z4} is a latent representation which we do not observe. What we observe is x ∈ R100 that is obtained via the following non-linear transformation:
x = σ(Uσ(Wz)),
whereW ∈ R10×4 and U ∈ R100×10 are matrices whose entries follow the zero-mean unit-variance i.i.d. Gaussian distribution, σ(·) is a sigmoid function to introduce nonlinearity. The generative model is shown in Fig. 4 (a). We define two clusters in facet Y1 and two clusters in facet Y2, and generate 5,000 samples of x. Under the above generative model, recovering the two facets Y1 and Y2 structure and the latent z domain from the observation of x seems very challenging. All previous DNN-based methods (AE+GMM, DEC, DCN, etc.) are only able to discover one-facet of clustering (i.e. one partition over the data), and none of these is applicable to solve such a multidimensional clustering problem. Fig. 4 (b) shows the results of the proposed method. As one can see, the LTVAE successfully discovers the true superstructure of Y1 and Y2. The 2-d plot of z1 and z2 shows the separable latent space clusters under facet Y1, and it matches the ground-truth cluster assignments. Additionally, the 2-d plot of z3 and z4 shows another separable clusters under facet Y2, and it also matches the ground-truth cluster assignments well in the other facet.

heading: 4.2 REAL-DATA EXPERIMENT SETUP
text: We evaluate the proposed LTVAE model on two image datasets and two other datasets, and compare it against other deep learning based clustering algorithms, including two-stage methods, AE+GMM and VAE+GMM, which first learn AE/VAE (Kingma & Welling, 2014) models then construct a GMM on top of them, and joint learning methods, DEC (Xie et al., 2016) and DCN (Yang et al., 2017). The datasets include MNIST, STL-10, Reuters (Xie et al., 2016; Jiang et al., 2017) and the Heterogeneity Human Activity Recognition (HHAR) dataset. When evaluating the clustering
performance, for fair of comparison, we follow previous works (Xie et al., 2016; Yang et al., 2017) and use the network structures of d−500−500−2000−10 for the encoder network and 10−2000− 500− 500− d for the decoder network for all datasets, where d is the data-space dimension, which varies among datasets. All layers are fully-connected. We follow the pretraining procedure as in (Xie et al., 2016). We first perform greedy layer-wise pretraining in denoising autoencoder manner, then stack all layers to form deep autoencoder. The deep autoencoder is further finetuned to minimize the reconstruction loss. The weights of the deep autoencoder are used to intialize the weights of encoder and decoder networks of above methods. After the pretraining, we optimze the objectives of those methods. For DEC and DCN, we use the same hyperparameter settings as the original papers. When initializing the cluster centroids for DEC and DCN, we perform 10 random restarts and pick the results with the best objective value for k-means/GMM. For the proposed LTVAE, we use Adam optimzer (Kingma & Ba, 2015) with initial learning rate of 0.001 and mini-batch size of 128. For Stepwise EM, we set the learning rate to be 0.01. As in Algorithm 1, we set E = 5, i.e. we update the latent tree model every 5 epochs. When optimizing the candidate models during structure search, we perform 10 random restarts and train with EM for 200 iterations.

heading: 4.3 TEST LOGLIKELIHOOD
text: We first show that, by using the marginal loglikelihood defined by the latent tree model as the prior, LTVAE better fits the data than conventional VAE and importance weighted autoencoders (IWAE) (Burda et al., 2016). While alternative quantitative criteria have been proposed (Bounliphone et al., 2016; Im et al., 2016; Salimans et al., 2016) for generative models, log-likelihood of held-out test data remains one of the most important measures of a generative model’s performance (Kingma & Welling, 2014; Burda et al., 2016; Wu et al., 2017; Goyal et al., 2017). For comparison, we approximate true loglikelihood L5000 using importance sampling (Burda et al., 2016): Lk(x) = log 1k ∑k i=1 pθ(x,z (i)) qφ(z(i)|x) , where z(i) ∼ qφ(z|x). The results for all datasets are shown in Table 1. The proposed LTVAE obtains a higher test data loglikelihood and ELBO, implying that it can better model the underlying complex data distribution embedded in the image data.

heading: 4.4 MULTIFACET CLUSTERING
text: The most important features of the proposed model are that it can perform variable selection for model-based clustering, leading to multiple facets clustering.
We use the standard unsupervised evaluation metric and protocols for evaluations and comparisons to other algorithms (Yang et al., 2010). For baseline algorithms we set the number of clusters to the number of ground-truth categories. While for LTVAE, it automatically determines the number of facets and latent superstructure through structure learning. We evaluate performance with unsupervised clustering accuracy (ACC):
ACC = max m
∑n i=1 1{li = m(ci)}
n ,
where li is the groundtruth label, ci is the cluster assignment produced by the algorithm, and m ranges over all possible mappings between clusters and labels. Table 2 show the quantitative clustering results compared with previous works. With z dimension of small value like 10, LTVAE usually discovers only one facet. It can be seen the, for MNIST dataset LTVAE achieves clustering accuracy of 86.32%, better than the results of other methods. This is also the case for STL-10, Reuters and HHAR.
More importantly, the proposed LTVAE does not just give one partition over the data. Instead, it explains the data in multi-faceted ways. Unlike previous clustering experiments, for this experiment, we choose the z dimension to be 20. Fig. 5 shows the two facet clustering results for MNIST. It can be seen that facet 1 gives quite clean clustering over the identity of the digits and the ten digits are well separated. On the other hand, facet 2 gives a more grand partition based on the shape and pose. Note how up-right “4” and “9” are similar, and how tilted “4”,“7” and “9” are similar. The facet meanings are more evident in Fig. 5 (c). Fig. 6 shows four facets discovered for the STL-10
dataset. Although it is hard to characterize precisely how the facets differ from each other, there are visible patterns. For example, the cats, monkeys and birds in facet 2 have clearly visible eyes, while this is not always true in facet 1. The deers in facet 2 are all showing their antlers/ears, while this is not true in facet 3. In facet 2 we see frontal views of cars, while in facets 1 and 3 we see side view of cars. In facet 1, each cluster consists of the same types of objects/animal. In facet 3/4, images in the same cluster do not necessarily show the same type of objects/animals. However, they have similar overall feel.

heading: 4.5 IMAGE GENERATION
text: Since the structure of the data in latent space is automatically learned through the latent tree, we can sample the data in a more structured way. One way is through ancestral sampling, where we first sample the root of the latent tree and then hierarchically sample the children variables to get z, from which the images can be generated through generation network. The other way is to pick one component from the Gaussian mixture and sample z from that component. This produces samples from a particular cluster. Fig. 7 shows the samples generated in this way. As it can be seen, digits sampled from each component has clear semantic meaning and belong to the same category. Whereas, the samples generated by VAE does not have such structure. Conditional image generation can also be performed to alter the attributes of the same digit as shown in Appendix B.

heading: 5 DISCUSSIONS
text: LTVAE learns the dependencies among latent variables Y. In general, latent variables are often correlated. For example, the social skills and academic skills of a student are generally correlated. Therefore, its better to model this relationship to better fit the data. Experiments show that removing such dependencies in LTVAE models results in inferior data loglikelihood.
In this paper, for the inference network, we simply use mean-field inference network with same structure as the generative network (Kingma & Welling, 2014). However, the limited expressiveness of the mean-field inference network could restrict the learning in the generative network and the quality of the learned model (Webb et al., 2018; Rainforth et al., 2018; Cremer et al., 2018). Using a faithful inference network structure as in (Webb et al., 2018) to incorporate the dependencies among latent variables in the posterior, for example one parameterized with masked autoencoder distribution estimator (MADE) model (Germain et al., 2015), could have a significant improvement in learning. We leave it for future investigation.

heading: 6 CONCLUSIONS
text: In this paper, we propose an unsupervised learning method, latent tree variational autoencoder (LTVAE), which simultaneously performs representation learning and multidimensional clustering. Different from previous deep learning based clustering methods, LTVAE learns latent embeddings from data and discovers multi-facet clustering structure based on subsets of latent features rather than one partition over data. Experiments show that the proposed method achieves state-of-the-art clustering performance and reals reasonable multifacet structures of the data.

heading: ACKNOWLEDGMENTS
text: Research on this article was supported by Hong Kong Research Grants Council under grants 16212516 and 16202118.

heading: A SUPERSTRUCTURES
text: For the MNIST dataset, the conditional probability between identity facet Y1 (x-axis) and pose facet Y2 (y-axis) is shown in Fig. 8. It can be seen that a cluster in Y1 facet could correspond to multiple clusters in Y2 facet due to the conditional probability, e.g. cluster 0, 4, 5, 11 and 12. However, not all clusters in Y2 facet are possible for a given cluster in Y1 facet.

heading: B CONDITIONAL IMAGE GENERATION
text: Here we show more results on conditional image generation. Interestingly, with LTVAE, we can change the original images by fixing variables in some facet and sampling in other facets. For example, in MNIST we can fix the variables in identity facet and change the pose of the digit by sampling in the pose facet. Fig. 9 shows the samples generated in this way. As it can be seen, the pose of the input digits are changed in the samples generated by the proposed method.

heading: C COMPUTATIONAL TIME
text: We compare the computational time of the proposed LTVAE w/ structure learning and that w/ fixed structure. For LTVAE with fixed structure, we fixed the structure of the latent tree model to be a single Y connecting to all zs, in which each z node consists of single z variable.

heading: D SIMILARITY BETWEEN LEARNED FACETS
text: Different facets learned by LTVAE might have some overlaps among each other. Here we make quantitative comparison among different facets based on the cluster assignments in each facet. We evaluate the similarity between two clusterings Y1 and Y2 using normalized mutual information NMI(Y1;Y2). The NMI is given by
NMI(Y1;Y2) = I(Y1;Y2)√ H(Y1)H(Y2) ,
where I(Y1;Y2) is the mutual information between Y1 and Y2 and H(V ) is the entropy of a variable V . These quantities can be computed from P (Y1;Y2), which in turn is estimated by P (Y1;Y2) = 1 N ∑N i=1 P (Y1|di)P (Y2|di), where d1, · · · ,dN are the samples in the test data.

heading: E DERIVATION OF GRADIENT
text: Here we give detailed derivation of Equation 6. The gradient gzb of the marginal loglikelihood log pS(z; Θ) w.r.t zb thus can be computed as
gzb = ∂ log pS(z; Θ)
∂zb
= 1
pS(z; Θ)
∂pS(z; Θ)
∂zb
= 1
pS(z; Θ)
∂ ∑ yb f(yb)N (zb|µyb ,Σyb)
∂zb = ∑ yb 1 pS(z; Θ) ∂[f(yb)N (zb|µyb ,Σyb)] ∂zb
= ∑ yb f(yb)N (zb|µyb ,Σyb) pS(z; Θ) ∂ log[f(yb)N (zb|µyb ,Σyb)] ∂zb
= ∑ yb p(yb|z) ∂ log[f(yb)N (zb|µyb ,Σyb)] ∂zb
= ∑ yb p(yb|z)Σ−1yb (µyb − zb)
(9)
where p(yb|z) is the posterior probability of yb and can be computed efficiently with message passing as described in the previous section. Note that
p(yb|z) = f(yb)N (zb|µyb ,Σyb)
pS(z; Θ) (10)
is valid due to pS(z; Θ) = ∑ yb N (zb|µyb ,Σyb)f(yb) and the Bayes rule.

Review summaries:
The authors propose to augment the Variational AutoEncoder [1] with a latent prior modeled by a Gaussian Latent Tree Model [2], allowing to introduce a hierarchical structure of clusters in the learned representation. The LT-VAE not only learns the location of each cluster to best represent the data, but also their number and the hierarchical structure of the underlying tree. This is achieved by a three-step learning algorithm. Step 1 is a traditional training of the encoder and decoder neural networks to improve their fitting of the data. Step 2 is an EM-like optimization to better fit the parameters of latent prior to the learned posterior. And step 3 adapts the structure of the latent prior to improve its BIC score [3], which balances a good fit of the latent posterior with the number of parameter (and thus complexity) of the latent prior.

This paper introduces a new VAE model, the latent tree VAE (LTVAE), which aims to learn models with multifaceted clustering, that is separate clusterings are enforced on different subsets of the latent features.  This is achieved using a tree-structured prior on a set of discrete "super latent variables" (Y_1,...,Y_L) that identify which cluster the datapoint falls into for each separate facet (i.e. there is a separate clustering associated with each Y_n).  The subset of the standard latent variables z then form a Gaussian mixture model (GMM) for each Y_n.   Both the structure of this setup (i.e. the associated graphical model) and the parameters (i.e. means and variances of the clusters) are learned during training.  This introduces a number of computational challenges not usually seen in for VAE training, for which, seemingly well thought through, novel schemes are introduced, most notably a message passing scheme for calculating gradients of the log marginal p(z).