Add files using upload-large-folder tool

parse/train/HJ_aoCyRZ/HJ_aoCyRZ.md

@@ -0,0 +1,542 @@
+# SPECTRALNET: SPECTRAL CLUSTERING USING DEEP NEURAL NETWORKS
+
+Uri Shaham∗†, Kelly Stanton∗, Henry Li∗   
+Yale University   
+New Haven, CT, USA   
+{uri.shaham, kelly.stanton, henry.li}@yale.edu
+
+# Yuval Kluger
+
+Boaz Nadler, Ronen Basri   
+Weizmann Institute of Science   
+Rehovot, Israel   
+{boaz.nadler, ronen.basri}@gmail.com
+
+Yale University New Haven, CT, USA yuval.kluger@yale.edu
+
+# ABSTRACT
+
+Spectral clustering is a leading and popular technique in unsupervised data analysis. Two of its major limitations are scalability and generalization of the spectral embedding (i.e., out-of-sample-extension). In this paper we introduce a deep learning approach to spectral clustering that overcomes the above shortcomings. Our network, which we call SpectralNet, learns a map that embeds input data points into the eigenspace of their associated graph Laplacian matrix and subsequently clusters them. We train SpectralNet using a procedure that involves constrained stochastic optimization. Stochastic optimization allows it to scale to large datasets, while the constraints, which are implemented using a specialpurpose output layer, allow us to keep the network output orthogonal. Moreover, the map learned by SpectralNet naturally generalizes the spectral embedding to unseen data points. To further improve the quality of the clustering, we replace the standard pairwise Gaussian affinities with affinities learned from the given unlabeled data using a Siamese network. Additional improvement of the resulting clustering can be achieved by applying the network to code representations produced, e.g., by standard autoencoders. Our end-to-end learning procedure is fully unsupervised. In addition, we apply VC dimension theory to derive a lower bound on the size of SpectralNet. State-of-the-art clustering results are reported on the Reuters dataset. Our implementation is publicly available at https://github.com/kstant0725/SpectralNet.
+
+# 1 INTRODUCTION
+
+Discovering clusters in unlabeled data is a task of significant scientific and practical value. With technological progress images, texts, and other types of data are acquired in large numbers. Their labeling, however, is often expensive, tedious, or requires expert knowledge. Clustering techniques provide useful tools to analyze such data and to reveal its underlying structure.
+
+Spectral Clustering (Shi & Malik, 2000; $\mathrm { N g }$ et al., 2002; Von Luxburg, 2007) is a leading and highly popular clustering algorithm. It works by embedding the data in the eigenspace of the Laplacian matrix, derived from the pairwise similarities between data points, and applying $k$ -means to this representation to obtain the clusters. Several properties make spectral clustering appealing: First, its embedding optimizes a natural cost function, minimizing pairwise distances between similar data points; moreover, this optimal embedding can be found analytically. Second, spectral clustering variants arise as relaxations of graph balanced-cut problems (Von Luxburg, 2007). Third, spectral clustering was shown to outperform other popular clustering algorithms such as $k$ -means (Von Luxburg, 2007), arguably due to its ability to handle non-convex clusters. Finally, it has a solid probabilistic interpretation, since the Euclidean distance in the embedding space is equal to a diffusion distance, which, informally, measures the time it takes probability mass to transfer between points, via all the other points in the dataset (Nadler et al., 2006; Coifman & Lafon, 2006a).
+
+![](images/cce14ac5e75034178b1104d64bd8efe36caa7ab333478be3aa3fab6b3217250f.jpg)  
+Figure 1: Illustrative 2D and 3D examples showing the results of our SpectralNet clustering (top) compared to typical results obtained with DCN, VaDE, DEPICT and IMSAT (bottom) on simulated datasets in 2D and 3D. Our approach successfully finds these non-convex clusters, whereas the competing algorithms fail on all five examples. (The full set of results for these algorithms is shown in Figure 4 in Appendix A.)
+
+While spectral embedding of data points can be achieved by a simple eigen-decomposition of their graph Laplacian matrix, with large datasets direct computation of eigenvectors may be prohibitive. Moreover, generalizing a spectral embedding to unseen data points, a task commonly referred to as out-of-sample-extension (OOSE), is a non-trivial task; see, for example, (Belkin et al., 2006; Bengio et al., 2004; Fowlkes et al., 2004; Coifman & Lafon, 2006b).
+
+In this work we introduce SpectralNet, a deep learning approach to spectral clustering, which addresses the scalability and OOSE problems pointed above. Specifically, SpectralNet is trained in a stochastic fashion, which allows it to scale. Moreover, once trained, it provides a function, implemented as a feed-forward network, that maps each input data point to its spectral embedding coordinates. This map can easily be applied to new test data. Unlike optimization of standard deep learning models, SpectralNet is trained using constrained optimization, where the constraint (orthogonality of the net outputs) is enforced by adding a linear layer, whose weights are set by the QR decomposition of its inputs. In addition, as good affinity functions are crucial for the success of spectral clustering, rather than using the common Euclidean distance to compute Gaussian affinity, we show how Siamese networks can be trained from the given unlabeled data to learn more informative pairwise distances and consequently significantly improve the quality of the clustering. Further improvement can be achieved if our network is applied to transformed data obtained by an autoencoder (AE). On the theoretical front, we utilize VC-dimension theory to derive a lower bound on the size of neural networks that compute spectral clustering. Our experiments indicate that our network indeed approximates the Laplacian eigenvectors well, allowing the network to cluster challenging non-convex point sets, which recent deep network based methods fail to handle; see examples in Figure 1. Finally, SpetralNet achieves competitive performance on MNIST handwritten digit dataset and state-of-the-art on the Reuters document dataset, whose size makes standard spectral clustering inapplicable.
+
+# 2 RELATED WORK
+
+Recent deep learning approaches to clustering largely attempt to learn a code for the input that is amenable to clustering according to either the $k$ -means or mixture of gaussians clustering models. DCN (Yang et al., 2017) directly optimizes a loss composed of a reconstruction term (for the code) and the $k$ -means functional. DEC (Xie et al., 2016) iteratively updates a target distribution to sharpen cluster associations. DEPICT (Dizaji et al., 2017) adds a regularization term that prefers balanced clusters. All three methods are pre-trained as autoencoders, while DEPICT also initializes its target distribution using $k$ -means or other standard clustering algorithms. Several other recent approaches rely on a variational autoencoder that utilizes a Gaussian mixture prior, see, for example, VaDE (Zheng et al., 2016) and GMVAE (Dilokthanakul et al., 2016). IMSAT (Hu et al., 2017) is based on data augmentation, where the net is trained to maximize the mutual information between inputs and predicted clusters, while regularizing the net so that the cluster assignment of original data points will be consistent with the assignment of augmented points. Different approaches are proposed by Chen (2015), who uses a deep belief net followed by non-parametric maximum margin clustering (NMMC), and by Yang et al. (2016), who introduce a recurrent-agglomerative framework to image clustering.
+
+While these approaches achieve accurate clustering results on standard datasets (such as the MNIST and Reuters), the use of the $k$ -means criterion, as well as the Gaussian mixture prior, seems to introduce an implicit bias towards the formation of clusters with convex shapes. This limitation seems to hold even in code space. This bias is demonstrated in Figure 1(bottom), which shows the failure of several of the above approaches on relatively simple clustering tasks. In contrast, as is indicated in Figure 1(top), our SpectralNet approach appears to be less vulnerable to such bias. The full set of runs can be found in Appendix A.
+
+In the context of spectral clustering, Tian et al. (2014) learn an autoencoder that maps the rows of a graph Laplacian matrix onto the corresponding spectral embedding, and then use $k$ -means in code space to cluster the underlying data. Unlike our work, which learns to map an input data point to its spectral embedding, Tian et al.’s network takes as input an entire row of the graph Laplacian, and therefore OOSE is impractical, as it requires to compute the affinities of each new data point to all the training data. Also of interest is the kernel spectral method by Alzate & Suykens (2010), which allows for out of sample extension and handles large datasets through smart sampling (but does not use a neural network).
+
+Yi et al. (2016) address the problem of 3D shape segmentation. Their work, which focuses on learning graph convolutions, uses a graph spectral embedding through eigenvector decomposition, which is not learned. In addition, we enforce orthogonalization stochastically through a constraint layer, while they attempt to learn orthogonalized functional maps by adding an orthogonalization term to the loss function, which involves non-trivial balancing between two loss components.
+
+Other deep learning works use a spectral approach in the context of supervised learning. Law et al. (2017) apply supervised metric learning, showing that their method approximates the eigenvectors of a 0-1 affinity matrix constructed from the true labels. Mishne et al. (2017) trained a network to compute graph Laplacian eigenvectors using supervised regression. Their approach, however, requires the true eigenvectors for training, and hence does not easily scale to large datasets.
+
+Finally, a number of papers showed that stochastic gradient descent can be used effectively to compute the principal components of covariance matrices, see, e.g., (Shamir, 2015) and references therein. The setup in these papers assumes that in each iteration a noisy estimate of the entire input matrix is provided. In contrast, in our work we use in each iteration only a small submatrix of the affinity matrix, corresponding to a small minibatch. In future work, we plan to examine how these algorithms can be adapted to improve the convergence rate of our proposed network.
+
+# 3 SPECTRALNET
+
+In this section we present our proposed approach, describe its key components, and explain its connection to spectral clustering. Consider the following standard clustering setup: Let $\scriptscriptstyle \textit { \textbf { X } } =$ $\{ x _ { 1 } , \ldots , x _ { n } \} \subseteq \mathbb { R } ^ { d }$ denote a collection of unlabeled data points drawn from some unknown distribution $\mathcal { D }$ ; given a target number of clusters $k$ and a distance measure between points, the goal is to learn a similarity measure between points in $\mathcal { X }$ and use it to learn a map that assigns each of $x _ { 1 } , \ldots , x _ { n }$ to one of $k$ possible clusters, so that similar points tend to be grouped in the same cluster. As in classification tasks we further aim to use the learned map to determine the cluster assignments of new, yet unseen, points drawn from $\mathcal { D }$ . Such out-of-sample-extension is based solely on the learned map, and requires neither computation of similarities between the new points and the training points nor re-clustering of combined data.
+
+In this work we propose SpectralNet, a neural network approach for spectral clustering. Once trained, SpectralNet computes a map $F _ { \theta } : \mathbb { R } ^ { d }  \mathbb { R } ^ { k }$ and a cluster assignment function $c : \mathbb { R } ^ { k } $ $\{ 1 , \ldots , k \}$ . It maps each input point $x$ to an output $y = F _ { \theta } ( x )$ and provides its cluster assignment $c ( y )$ . The spectral map $F _ { \theta }$ is implemented using a neural network, and the parameter vector $\theta$ denotes the network weights.
+
+The training of SpectralNet consists of three components: (i) unsupervised learning of an affinity given the input distance measure, via a Siamese network (see Section 3.2); (ii) unsupervised learning of the map $F _ { \theta }$ by optimizing a spectral clustering objective while enforcing orthogonality (see Section 3.1); (iii) learning the cluster assignments, by k-means clustering in the embedded space.
+
+# 3.1 LEARNING THE SPECTRAL MAP $F _ { \theta }$
+
+In this section we describe the main learning step in SpectralNet, component (ii) above. To this end, let $w : \mathbb { R } ^ { d } \times \mathbb { R } ^ { d } \to [ 0 , \infty )$ be a symmetric affinity function, such that $w ( x , x ^ { \prime } )$ expresses the similarity between $x$ and $x ^ { \prime }$ . Given $w$ , we would like points $x , x ^ { \prime }$ which are similar to each other (i.e., with large $w ( x , x ^ { \prime } ) )$ to be embedded close to each other. Hence, we define the loss
+
+$$
+\begin{array} { r } { \mathcal { L } _ { \mathrm { S p e c t r a l N e t } } ( \theta ) = \mathbb { E } \left[ w ( x , x ^ { \prime } ) \lVert y - y ^ { \prime } \rVert ^ { 2 } \right] , } \end{array}
+$$
+
+where $y , y ^ { \prime } \in \mathbb { R } ^ { k }$ , the expectation is taken with respect to pairs of i.i.d. elements $( x , x ^ { \prime } )$ drawn from $\mathcal { D }$ , and $\theta$ denotes the parameters of the map $y = F _ { \theta } ( x )$ . Clearly, the loss $\mathcal { L } _ { \mathrm { S p e c t r a l N e t } } ( \theta )$ can be minimized by mapping all points to the same output vector $( F _ { \theta } ( x ) = y _ { 0 }$ for all $x$ ). To prevent this, we require that the outputs will be orthonormal in expectation with respect to $\mathcal { D }$ , i.e.,
+
+$$
+\mathbb { E } \left[ y y ^ { T } \right] = I _ { k \times k } .
+$$
+
+As the distribution $\mathcal { D }$ is unknown, we replace the expectations in (1) and (2) by their empirical analogues. Furthermore, we perform the optimization in a stochastic fashion. Specifically, at each iteration we randomly sample a minibatch of $m$ samples, which without loss of generality we denote $x _ { 1 } , \ldots , x _ { m } \in \mathcal { X }$ , and organize them in an $m \times d$ matrix $X$ whose $i$ th row contains $x _ { i } ^ { T }$ . We then minimize the loss
+
+$$
+L _ { { \mathrm { S p e c t r a l N e t } } } ( \theta ) = \frac { 1 } { m ^ { 2 } } \sum _ { i , j = 1 } ^ { m } W _ { i , j } \| y _ { i } - y _ { j } \| ^ { 2 } ,
+$$
+
+where $y _ { i } = F _ { \theta } ( x _ { i } )$ and $W$ is a $m \times m$ matrix such that $W _ { i , j } = w ( x _ { i } , x _ { j } )$ . The analogue of (2) for a small minibatch is
+
+$$
+{ \frac { 1 } { m } } Y ^ { T } Y = I _ { k \times k } ,
+$$
+
+where $Y$ is a $m \times k$ matrix of the outputs whose $i$ th row is $y _ { i } ^ { T }$
+
+We implement the map $F _ { \theta }$ as a general neural network whose last layer enforces the orthogonality constraint (4). This layer gets input from $k$ units, and acts as a linear layer with $k$ outputs, where the weights are set to orthogonalize the output $Y$ for the minibatch $X$ . Let $\tilde { Y }$ denote the $m \times k$ matrix containing the inputs to this layer for $X$ (i.e., the outputs of $F _ { \theta }$ over the minibatch before orthogonalization). A linear map that orthogonalizes the columns of $\tilde { Y }$ is computed through its QR decomposition. Specifically, for any matrix $A$ such that $A ^ { T } A$ is full rank, one can obtain the QR decomposition via the Cholesky decomposition $A ^ { T } A = L L ^ { T }$ , where $L$ is a lower triangular matrix, and then setting $Q \ : = \ : A \left( L ^ { - 1 } \right) ^ { T }$ . This is verified in Appendix B. Therefore, in order to orthogonalize $\tilde { Y }$ , the last layer multiplies $\tilde { Y }$ from the right by $\sqrt { m } \left( \tilde { L } ^ { - 1 } \right) ^ { T }$ , where $\tilde { L }$ is obtained from the Cholesky decomposition of $\tilde { Y } ^ { T } \tilde { Y }$ and the $\sqrt { m }$ factor is needed to satisfy (4).
+
+We train this spectral map in a coordinate descent fashion, where we alternate between orthogonalization and gradient steps. Each of these steps uses a different minibatch (possibly of different sizes), sampled uniformly from the training set $\mathcal { X }$ . In each orthogonalization step we use the QR decomposition to tune the weights of the last layer. In each gradient step we tune the remaining weights using standard backpropagation. Once SpectralNet is trained, all the weights are freezed, including those of the last layer, which simply acts as a linear layer. Finally, to obtain the cluster assignments $c _ { 1 } , \ldots c _ { 2 }$ , we propagate $x _ { 1 } , \ldots . x _ { n }$ through it to obtain the embeddings $y _ { 1 } , \ldots , y _ { n } \in \mathbb { R } ^ { k }$ , and perform $k$ -means on them, obtaining $k$ cluster centers, as in standard spectral clustering. These algorithmic steps are summarized below in Algorithm 1 in Sec. 3.3.
+
+# Connection with Spectral Clustering The loss (3) can also be written as
+
+$$
+L _ { \mathrm { S p e c t r a l N e t } } ( \theta ) = \frac { 2 } { m ^ { 2 } } \operatorname { t r a c e } \left( Y ^ { T } ( D - W ) Y \right) ,
+$$
+
+where $D$ is a $m \times m$ diagonal matrix such that $\begin{array} { r } { D _ { i , i } = \sum _ { j } W _ { i , j } } \end{array}$ . The symmetric, positive semidefinite matrix $D - W$ forms the (unnormalized) graph Laplacian of the minibatch $x _ { 1 } , \ldots , x _ { m }$ . For $k = 1$ the loss is minimized when $y$ is the eigenvector of $D - W$ corresponding to the smallest eigenvalue. Similarly, for general $k$ , under the constraint (4), the minimum is attained when the column space of $Y$ is the subspace of the $k$ eigenvectors corresponding to the smallest $k$ eigenvalues of $D - W$ . Note that this subspace includes the constant vector whose inclusion does not affect the final cluster assignment.
+
+Hence, SpectralNet approximates spectral clustering, where the main differences are that the training is done in a stochastic fashion, and that the orthogonality constraint with respect to the full dataset $\mathcal { X }$ holds only approximately. SpectralNet therefore trades accuracy with scalability and generalization ability. Specifically, while its outputs are an approximation of the true eigenvectors, the stochastic training enables its scalability and thus allows one to cluster large datasets that are prohibitive for standard spectral clustering. Moreover, once trained, SpectralNet provides a parametric function whose image for the training points is (approximately) the eigenvectors of the graph Laplacian. This function can now naturally embed new test points, which were not present at training time. Our experiments with the MNIST dataset (Section 5) indicate that the outputs of SpectralNet closely approximate the true eigenvectors.
+
+Finally, as in common spectral clustering applications, cluster assignments are determined by applying $k$ -means to the embeddings $y _ { 1 } , \ldots y _ { n }$ . We note that the $k$ -means step can be replaced by other clustering algorithms. Our preference to use $k$ -means is based on the interpretation (for normalized Laplacian matrices) of the Euclidean distance in the embedding space as diffusion distance in the input space (Nadler et al., 2006; Coifman $\&$ Lafon, 2006a).
+
+Normalized graph Laplacian In spectral clustering, the symmetric normalized graph Laplacian $I - D ^ { - { \frac { 1 } { 2 } } } W D ^ { - { \frac { 1 } { 2 } } }$ can use as an alternative to the unnormalized Laplacian $D - W$ . In order to train SpectralNet with normalized graph Laplacian, the loss function (3) should be replaced by
+
+$$
+L _ { \mathrm { S p e c t r a l N e t } } ( \theta ) = \frac { 1 } { m ^ { 2 } } \sum _ { i , j = 1 } ^ { m } W _ { i , j } \left\| \frac { y _ { i } } { d _ { i } } - \frac { y _ { j } } { d _ { j } } \right\| ^ { 2 } ,
+$$
+
+where $\begin{array} { r } { d _ { i } = D _ { i , i } = \sum _ { j = 1 } ^ { m } W _ { i , j } } \end{array}$
+
+Batch size considerations Typically in classification or regression, the loss is a sum over the losses of individual examples. In contrast, SpectralNet loss (3) is summed over pairs of points, and each summand describes relationships between data points. This relation is encoded by the full $n \times n$ affinity matrix $W _ { \mathrm { f u l l } }$ (which we never compute explicitly). The minibatch size $m$ should therefore be sufficiently large to capture the structure of the data. For this reason, it is also highly important that minibatches will be sampled at random from the entire dataset at each step, and not be fixed across epochs. When the minibatches are fixed, the knowledge of $W _ { \mathrm { f u l l } }$ is reduced to a (possibly permuted) diagonal sequence of $m \times m$ blocks, thus ignoring many of the entries of $W _ { \mathrm { f u l l } }$ . In addition, while the output layer orthogonalizes $\tilde { Y }$ , we do not have any guarantees on how well it orthogonalizes other random minibatches. However, in our experiments we observed that if $m$ is large enough, it approximately orthogonalizes other batches as well, and its weights stabilize as training progresses. Therefore, to train SpectralNet, we use larger minibatches compared to common choices made by practitioners in the context of classification. In our experiments we use minibatches of size 1024 for MNIST and 2048 for Reuters, re-sampled randomly at every step.
+
+# 3.2 LEARNING AFFINITIES USING A SIAMESE NETWORK
+
+Choosing a good affinity measure is crucial to the success of spectral clustering. In many applications, practitioners use an affinity measure that is positive for a set of nearest neighbor pairs, combined with a Gaussian kernel with some scale $\sigma > 0$ , e.g.,
+
+$$
+W _ { i , j } = \left\{ \begin{array} { l l } { \exp \left( - \frac { \| x _ { i } - x _ { j } \| ^ { 2 } } { 2 \sigma ^ { 2 } } \right) , } & { ~ x _ { j } \mathrm { ~ i s ~ a m o n g ~ t h e ~ n e a r e s t ~ n e i g h b o r s ~ o f ~ } x _ { i } } \\ { 0 , } & { \mathrm { ~ o t h e r w i s e , } } \end{array} \right.
+$$
+
+where one typically symmetrizes $W$ , for example, by setting $W _ { i , j } \gets ( W _ { i , j } + W _ { j , i } ) / 2$
+
+Euclidean distance may be overly simplistic measure of similarity; seeking methods that can capture more complex similarity relations might turn out advantageous. Siamese nets (Hadsell et al., 2006; Shaham & Lederman, 2018) are trained to learn affinity relations between data points; we empirically found that the unsupervised application of a Siamese net to determine the distances often improves the quality of the clustering.
+
+Siamese nets are typically trained on a collection of similar (positive) and dissimilar (negative) pairs of data points. When labeled data are available, such pairs can be chosen based on label information (i.e., pairs of points with the same label are considered positive, while pairs of points with different labels are considered negative). Here we focus on datasets that are unlabeled. In this case we can learn the affinities directly from Euclidean proximity or from graph distance, e.g., by “labeling” points $x _ { i } , x _ { j }$ positive if $\| x _ { i } - x _ { j } \|$ is small and negative otherwise. In our experiments, we construct positive pairs from the nearest neighbors of each point. Negative pairs are constructed from points with larger distances. This Siamese network, therefore, is trained to learn an adaptive nearest neighbor metric.
+
+A Siamese net maps every data point $x _ { i }$ into an embedding $z _ { i } = G _ { \theta _ { \mathrm { s i a m e s e } } } ( x _ { i } )$ in some space. The net is typically trained to minimize contrastive loss, defined as
+
+$$
+L _ { \mathrm { s i a m e s e } } ( \theta _ { \mathrm { s i a m e s e } } ; x _ { i } , x _ { j } ) = \left\{ \begin{array} { l l } { \| z _ { i } - z _ { j } \| ^ { 2 } , } & { ( x _ { i } , x _ { j } ) \mathrm { ~ i s ~ a ~ p o s i t i v e ~ p a i r } } \\ { \operatorname* { m a x } \left( c - \| z _ { i } - z _ { j } \| , 0 ) \right) ^ { 2 } , } & { ( x _ { i } , x _ { j } ) \mathrm { ~ i s ~ a ~ n e g a t i v e ~ p a i r } , } \end{array} \right.
+$$
+
+where $c$ is a margin (typically set to 1).
+
+Once the Siamese net is trained, we use it to define a batch affinity matrix $W$ for the training of SpectralNet, by replacing the Euclidean distance $\| x _ { i } - x _ { j } \|$ in (6) with $\| z _ { i } - z _ { j } \|$ .
+
+Remarkably, despite being trained in an unsupervised fashion on a training set constructed from relatively naive nearest neighbor relations, in Section 5 we show that affinities that use the Siamese distances yield dramatically improved clustering quality over affinities that use Euclidean distances. This implies that unsupervised training of Siamese nets can lead to learning useful and rich affinity relations.
+
+# 3.3 ALGORITHM
+
+Our end-to-end training approach is summarized in Algorithm 1.
+
+Input: $\mathcal { X } \subseteq \mathbb { R } ^ { d }$ , number of clusters $k$ , batch size $m$
+
+Output: embeddings $y _ { 1 } , \dots , y _ { n } , \ y _ { i } \in \mathbb { R } ^ { k }$ , cluster assignments $c _ { 1 } , \ldots c _ { n } , \ c _ { i } \in \{ 1 , \ldots k \}$ Construct a training set of positive and negative pairs for the Siamese network; Train a Siamese network;
+
+Randomly initialize the network weights $\theta$ ; while $L _ { S p e c t r a l N e t } ( \theta )$ not converged do
+
+# Orthogonalization step:
+
+Sample a random minibatch $X$ of size $m$ ;
+
+Forward propagate $X$ and compute inputs to orthogonalization layer $\tilde { Y }$ ;
+
+Compute the Cholesky factorization $L L ^ { T } = \tilde { Y } ^ { T } \tilde { Y }$
+
+Set the weights of the orthogonalization layer to be $\sqrt { m } \left( L ^ { - 1 } \right) ^ { T }$ ;
+
+# Gradient step:
+
+Sample a random minibatch $x _ { 1 } , \ldots , x _ { m }$ ;   
+Compute the $m \times m$ affinity matrix $W$ using the Siamese net;   
+Forward propagate $x _ { 1 } , \ldots , x _ { m }$ to get $y _ { 1 } , \ldots , y _ { m }$ ;   
+Compute the loss (3) or (5);   
+Use the gradient of $L _ { \mathrm { S p e c t r a l N e t } } ( \theta )$ to tune all $F _ { \theta }$ weights, except those of the output layer;
+
+# end
+
+Forward propagate $x _ { 1 } , \ldots , x _ { n }$ and obtain $F _ { \theta }$ outputs $y _ { 1 } , \ldots , y _ { n }$ ;   
+Run $k$ -means on $y _ { 1 } , \ldots , y _ { n }$ to determine cluster centers;
+
+Algorithm 1: SpectralNet training
+
+Once SpectralNet is trained, computing the embeddings of new test points (i.e., out-of-sampleextension) and their cluster assignments is straightforward: we simply propagate each test point $x _ { i }$ through the network $F _ { \theta }$ to obtain their embeddings $y _ { i }$ , and assign the point to its nearest centroid, where the centroids were computed using $k$ -means on the training data, at the last line of Algorithm 1.
+
+# 3.4 SPECTRAL CLUSTERING IN CODE SPACE
+
+Given a dataset $\mathcal { X }$ , one can either apply SpectralNet in the original input space, or in a code space (obtained, for example, by an autoencoder). A code space representation is typically lower dimensional, and often contains less nuisance information (i.e., information on which an appropriate similarity measure should not depend). Following (Yang et al., 2017; Xie et al., 2016; Zheng et al., 2016) and others, we empirically observed that SpectralNet performs best in code space. Unlike these works, which use an autoencoder as an initialization for their clustering networks, we use the code as our data representation and apply SpectralNet directly in that space, (i.e., we do not change the code space while training SpectralNet). In our experiments, we use code spaces obtained from publicly available autoencoders trained by Zheng et al. (2016) on the MNIST and Reuters datasets.
+
+# 4 THEORETICAL ANALYSIS
+
+Our proposed SpectralNet not only determines cluster assignments in training, as clustering algorithms commonly do, but it also produces a map that can generalize to unseen data points at test time. Given a training set with $n$ points, it is thus natural to ask how large should such a network be to represent this spectral map. The theory of VC-dimension can provide useful worst-case bounds for this size.
+
+In this section, we use the VC dimension theory to study the minimal size a neural network should have in order to compute spectral clustering for $k = 2$ . Specifically, we consider the class of functions that map all training points to binary values, determined by thresholding at zero the eigenvector of the graph Laplacian with the second smallest eigenvalue. We denote this class of binary classifiers $\mathcal { F } _ { n } ^ { \mathrm { s g } }$ ectral clustering. Note that with $k = 2$ , $k$ -means can be replaced by thresholding of the second smallest eigenvector, albeit not necessarily at zero. We are interested in the minimal number of weights and neurons required to allow the net to compute such functions, assuming the affinities decay exponentially with the Euclidean distance. We do so by studying the VC dimension of function classes obtained by performing spectral clustering on $n$ points in arbitrary Euclidean spaces $\mathbb { R } ^ { d }$ , with $d \geq 3$ . We will make no assumption on the underlying distribution of the points.
+
+In the main result of this section, we prove a lower bound on the VC dimension of spectral clustering, which is linear in the number of points $n$ . In contrast, the VC dimension of $k$ -means, for example, depends solely on the dimension $d$ , but not on $n$ , hence making $k$ -means significantly less expressive than spectral clustering1. As a result of our main theorem, we bound from below the number of weights and neurons in any net that is required to compute Laplacian eigenvectors. The reader might find the analysis in this section interesting in its own right.
+
+Our main result shows that for data in $\mathbb { R } ^ { d }$ with $d \geq 3$ , the VC dimension of $\mathcal { F } _ { n } ^ { \mathrm { s p e c t r a l ~ c l u s t e r i n g } }$ is linear in the number $n$ of points, making spectral clustering almost as rich as arbitrary clustering of the $n$ points.
+
+Theorem 4.1. VC dim(F spectral clusteringn ) ≥ 110 n.
+
+The formal proof of Theorem 4.1 is deferred to Appendix C. Below we informally sketch its principles. We show that for any integer $n$ (assuming for simplicity that $n$ is divisible by 10), there exists a set of $m = n / 1 0$ points in $\mathbb { R } ^ { d }$ that is shattered by $\mathcal { F } _ { n } ^ { \mathrm { s p } }$ ectral clustering. In particular, we show this for the set of $m$ points placed in a 2-dimensional grid in $\mathbb { R } ^ { d }$ . We then show that for any arbitrary dichotomy of these $m$ points, we can augment the set of points to a larger set $X$ , containing $n = 1 0 m$ points, with a balanced partition of $X$ into two disjoint sets $S$ and $T$ that respects the dichotomy of the original $m$ points. The larger set has the special properties: (1) within $S$ (and resp. $T$ ), there is a path between any two points such that the distances between all pairs of consecutive points along the path are small, and (2) all pairs $( s , t ) \in S \times T$ are far apart. We complete the proof by constructing a Gaussian affinity $W$ with a suitable value of $\sigma$ and showing that the minimizer of the spectral clustering loss for $( X , W )$ (i.e., the second eigenvector of the Laplacian), when thresholded at 0, separates $S$ from $T$ , and hence respects the original dichotomy.
+
+By connecting Theorem 4.1 with known results regarding the VC dimension of neural nets, see, e.g., (Shalev-Shwartz & Ben-David, 2014), we can bound the size from below (in terms of number of weights and neurons) of any neural net that computes spectral clustering. This is formalized in the following corollary.
+
+# Corollary 4.2.
+
+1. For the class of neural nets with $| v |$ sigmoid nodes and $| w |$ weights to represent all functions realizable by spectral clustering (i.e., second eigenvector of the Laplacian, thresholded at 0) on n points, it is necessary to have $| w | ^ { 2 } | v | ^ { 2 } \geq O ( n )$ .   
+2. For the class of neural nets with $| w |$ weights from a finite family (e.g., single-precision weights) to represent all functions realizable by spectral clustering, it is necessary to have $| w | \geq O ( n )$ .
+
+#
+
+1. The VC dimension of the class of neural nets with $| v |$ sigmoid units and $| w |$ weights is at most $O ( | w | ^ { 2 } | v | ^ { 2 } )$ (Shalev-Shwartz & Ben-David, 2014, p. 275). Hence, if $| w | ^ { 2 } \bar { | v | } ^ { 2 } <$ $O ( n )$ , such net cannot shatter any collection of points of size $O ( n )$ . From Theorem 4.1, $\mathcal { F } _ { n } ^ { \mathrm { s p e c t r a l ~ c l u s t e r i n g } }$ shatters at least $O ( n )$ points. Therefore, in order for a class of networks to be able to express any function that can be computed using spectral clustering, it is a necessary (but not sufficient) condition to satisfy $| w | ^ { 2 } | v | ^ { 2 } \geq O ( n )$ .
+
+2. The VC dimension of the class of neural nets with $| w |$ weights from a finite family is $O ( w )$ (Shalev-Shwartz & Ben-David, 2014, p. 276). The arguments above imply that $| w | \geq$ $O ( n )$ .
+
+Corollary 4.2 implies that in the general case (i.e., without assuming any structure on the $n$ data points), to perform spectral clustering, the size of the net has to grow with $n$ . However, when the data has some geometric structure, the net size can be much smaller. Indeed, in a related result, the ability of neural networks to learn eigenvectors of Laplacian matrices was demonstrated both empirically and theoretically by Mishne et al. (2017). They proved that there exist networks which approximate the eigenfunctions of manifold Laplacians arbitrarily well (where the size of the network depends on the desired error and the parameters of the manifold, but not on $n$ ).
+
+# 5 EXPERIMENTAL RESULTS
+
+# 5.1 EVALUATION METRICS
+
+To numerically evaluate the accuracy of the clustering, we use two commonly used measures, the unsupervised clustering accuracy (ACC), and the normalized mutual information (NMI). For completeness, we define ACC and NMI below, and refer the reader to (Cai et al., 2011) for more details. For data point $x _ { i }$ , let $l _ { i }$ and $c _ { i }$ denote its true label and predicted cluster, respectively. Let $l = ( l _ { 1 } , \ldots l _ { n } )$ and similarly $c = ( c _ { 1 } , \ldots c _ { n } )$ .
+
+ACC is defined as
+
+$$
+\operatorname { A C C } ( l , c ) = { \frac { 1 } { n } } \operatorname* { m a x } _ { \pi \in \Pi } \sum _ { i = 1 } ^ { n } \mathbb { 1 } \left\{ l _ { i } = \pi \left( c _ { i } \right) \right\} ,
+$$
+
+where $\Pi$ is the collection of all permutations of $\{ 1 , \ldots k \}$ . The optimal permutation $\pi$ can be computed using the Kuhn-Munkres algorithm (Munkres, 1957).
+
+Table 1: Performance of various clustering methods on MNIST and Reuters datasets. $( ^ { * } )$ reported in (Xie et al., 2016). $( ^ { * * } )$ reported in (Yang et al., 2017), $( ^ { \dag } )$ reported in (Zheng et al., 2016), $( ^ { \ddagger } )$ ) reported in (Dizaji et al., 2017), $( ^ { \dag \dag } )$ reported in (Yang et al., 2016), $( ^ { \ddagger \ddagger } )$ reported in (Hu et al., 2017). The IMSAT result on Reuters was obtained on a subset of 10,000 from the full dataset.   
+
+<table><tr><td rowspan=1 colspan=1>Algorithm</td><td rowspan=1 colspan=1>ACC (MNIST)</td><td rowspan=1 colspan=1>NMI (MNIST)</td><td rowspan=1 colspan=1>ACC(Reuters)</td><td rowspan=1 colspan=1>NMI (Reuters)</td></tr><tr><td rowspan=1 colspan=1>k-means</td><td rowspan=1 colspan=1>.534</td><td rowspan=1 colspan=1>.499</td><td rowspan=1 colspan=1>.533</td><td rowspan=1 colspan=1>.401</td></tr><tr><td rowspan=1 colspan=1>Spectral clustering</td><td rowspan=1 colspan=1>.717</td><td rowspan=1 colspan=1>.754</td><td rowspan=1 colspan=1>NA</td><td rowspan=1 colspan=1>NA</td></tr><tr><td rowspan=1 colspan=1>DEC</td><td rowspan=1 colspan=1>.843*</td><td rowspan=1 colspan=1>.8**</td><td rowspan=1 colspan=1>.756*</td><td rowspan=1 colspan=1>not reported</td></tr><tr><td rowspan=1 colspan=1>DCN</td><td rowspan=1 colspan=1>.83**</td><td rowspan=1 colspan=1>.81**</td><td rowspan=1 colspan=1>not reported</td><td rowspan=1 colspan=1>not reported</td></tr><tr><td rowspan=1 colspan=1>VaDE</td><td rowspan=1 colspan=1>.9446†</td><td rowspan=1 colspan=1>not reported</td><td rowspan=1 colspan=1>.7938†</td><td rowspan=1 colspan=1>not reported</td></tr><tr><td rowspan=1 colspan=1>JULE</td><td rowspan=1 colspan=1>not reported</td><td rowspan=1 colspan=1>.913</td><td rowspan=1 colspan=1>not reported</td><td rowspan=1 colspan=1>not reported</td></tr><tr><td rowspan=1 colspan=1>DEPICT</td><td rowspan=1 colspan=1>.965tt</td><td rowspan=1 colspan=1>.9171t</td><td rowspan=1 colspan=1>not reported</td><td rowspan=1 colspan=1>not reported</td></tr><tr><td rowspan=1 colspan=1>IMSAT</td><td rowspan=1 colspan=1>.984±.004‡#</td><td rowspan=1 colspan=1>not reported</td><td rowspan=1 colspan=1>.719</td><td rowspan=1 colspan=1>not reported</td></tr><tr><td rowspan=1 colspan=1>SpectralNet (input space,Euclidean distance)</td><td rowspan=1 colspan=1>.622±.008</td><td rowspan=1 colspan=1>.687±.004</td><td rowspan=1 colspan=1>.645±.01</td><td rowspan=1 colspan=1>.444±.01</td></tr><tr><td rowspan=1 colspan=1>SpectralNet (input space,Siamese distance)</td><td rowspan=1 colspan=1>.826±.03</td><td rowspan=1 colspan=1>.884±.02</td><td rowspan=1 colspan=1>.661± 017</td><td rowspan=1 colspan=1>.381 ± .057</td></tr><tr><td rowspan=1 colspan=1>SpectralNet (code space,Euclidean distance)</td><td rowspan=1 colspan=1>.800±.003</td><td rowspan=1 colspan=1>.814±.008</td><td rowspan=1 colspan=1>.605±.053</td><td rowspan=1 colspan=1>.401±.061</td></tr><tr><td rowspan=1 colspan=1>SpectralNet (code space, Siamese distance)</td><td rowspan=1 colspan=1>.971±.001</td><td rowspan=1 colspan=1>.924±.001</td><td rowspan=1 colspan=1>.803±.006</td><td rowspan=1 colspan=1>.532±.010</td></tr></table>
+
+NMI is defined as
+
+$$
+\operatorname { N M I } ( l , c ) = \frac { I ( l ; c ) } { \operatorname* { m a x } \{ H ( l ) , H ( c ) \} } ,
+$$
+
+where $I ( l ; c )$ denotes the mutual information between $l$ and $c$ , and $H ( \cdot )$ denotes their entropy. Both ACC and NMI are in $[ 0 , 1 ]$ , with higher values indicating better correspondence the clusters and the true labels.
+
+# 5.2 CLUSTERING
+
+We compare SpectralNet to several deep learning-based clustering approaches on two real world datasets. In all runs we assume the number of clusters is given $_ { \mathrm { k = 1 0 } }$ in MNIST and ${ \bf k } { = } 4$ in Reuters). As a reference, we also report the performance of $k$ -means and (standard) spectral clustering. Specifically, we compare SpectralNet to DEC (Xie et al., 2016), DCN (Yang et al., 2017), VaDE (Zheng et al., 2016), JULE (Yang et al., 2016), DEPICT (Dizaji et al., 2017), and IMSAT (Hu et al., 2017). The results for these six methods are reported in the corresponding papers. Technical details regarding the application of $k$ -means and spectral clustering appear in Appendix D.
+
+We considered two variants of Gaussian affinity functions: using Euclidean distances (6), and Siamese distances; the latter case follows Algorithm 1. In all experiments we used the loss (3). In addition, we report results of SpectralNet (and the Siamese net) in both input space and code space. The code spaces are obtained using the publicly available autoencoders which are used to pre-train the weights of $\mathrm { V a D E } ^ { 2 }$ , and are 10-dimensional. We refer the reader to Appendix D for technical details about the architectures and training procedures.
+
+# 5.2.1 MNIST
+
+MNIST is a collection of $7 0 , 0 0 0 2 8 \times 2 8$ gray-scale images of handwritten digits, divided to training (60,000) and test (10,000) sets. To construct positive pairs for the Siamese net, we paired each instance with its two nearest neighbors. An equal number of negative pairs were chosen randomly from non-neighboring points.
+
+Table 1 shows the performance of the various clustering algorithms on the MNIST dataset, using all 70,000 images for training. As can be seen, the performance of SpectralNet is significantly improved when using Siamese distance instead of Euclidean distance, and when the data is represented in code space rather than in pixel space. With these two components, SpectralNet outperforms DEC, DCN, VaDE, DEPICT and JULE, and is competitive with IMSAT.
+
+To evaluate how well the outputs of SpectralNet approximate the true eigenvectors of the graph Laplacian, we compute the Grassmann distance between the subspace of SpectralNet outputs and that of the true eigenvectors. The squared Grassmann distance measures the sum of squared sines of the angles between two $k$ -dimensional subspaces; the distance is in $[ 0 , k ]$ . Figure 2 shows the Grassmann distance on the MNIST dataset as a function of the training time (expressed as number of parameter updates). It can be seen that the distance decreases rapidly at the beginning of training and stabilizes around 0.026 as time progresses.
+
+![](images/f93e3b7ecef14241f849e4c0db9373612fcec33d0574b020c421e8c5db2e56f1.jpg)  
+Figure 2: Grassmann distance as a function of iteration update for the MNIST dataset.
+
+To check the generalization ability of SpectralNet to new test points, we repeated the experiment, this time training SpectralNet only on the training set, and predicting the labels of the test examples by passing them through the net and associating each test example with the nearest centroid from the $k$ -means that were performed on the embedding of the training examples. The accuracy on test examples was .970, implying that SpectralNet generalizes well to unseen test data in this case. We similarly also evaluated the generalization performance of $\mathbf { k }$ -means. The accuracy of $\mathbf { k }$ -means on the test set is .546 when using the input space and .776 when using the code space, both significantly inferior to SpectralNet.
+
+# 5.2.2 REUTERS
+
+The Reuters dataset is a collection of English news, labeled by category. Like DEC and VaDE, we used the following categories: corporate/industrial, government/social, markets, and economics as labels and discarded all documents with multiple labels. Each article is represented by a tfidf vector, using the $2 0 0 0 \ \mathrm { m o s t }$ frequent words. The dataset contains $n = 6 8 5 , 0 7 1$ documents. Performing vanilla spectral clustering on a dataset of this size in a standard way is prohibitive. The AE used to map the data to code space was trained based on a random subset of 10,000 samples from the full dataset. To construct positive pairs for the Siamese net, we randomly sampled 300,000 examples from the entire dataset, and paired each one with a random neighbor from its 3000 nearest neighbors. An equal number of negative pairs was obtained by randomly pairing each point with one of the remaining points.
+
+Table 1 shows the performance of the various algorithms on the Reuters dataset. Overall, we see similar behavior to what we observed on MNIST: SpectralNet outperforms all other methods, and performs best in code space, and using Siamese affinity. Our SpectralNet implementation took less than 20 minutes to learn the spectral map on this dataset, using a GeForce GTX 1080 GPU. For comparison, computing the top four eigenvectors of the Laplacian matrix of the complete data, needed for spectral clustering, took over 100 minutes using ARPACK. Note that both SpectralNet and spectral clustering require pre-computed nearest neighbor graph. Moreover, spectral clustering using the ARPACK eigenvectors failed to produce reasonable clustering. This illustrates the robustness of our method in contrast to the well known instability of spectral clustering to outliers.
+
+To evaluate the generalization ability of SpectralNet, we divided the data randomly to a $90 \%$ - $10 \%$ split, re-trained the Siamese net and SpectralNet on the larger subset, and predicted the labels of the smaller subset. The test accuracy was 0.798, implying that as on MNIST, SpectralNet generalizes well to new examples.
+
+# 6 CONCLUSIONS
+
+We have introduced SpectralNet, a deep learning approach for approximate spectral clustering. The stochastic training of SpectralNet allows us to scale to larger datasets than what vanilla spectral clustering can handle, and the parametric map obtained from the net enables straightforward out of sample extension. In addition, we propose to use unsupervised Siamese networks to compute distances, and empirically show that this results in better performance, comparing to standard Euclidean distances. Further improvement are achieved by applying our network to code representations produced with a standard stacked autoencoder. We present a novel analysis of the VC dimension of spectral clustering, and derive a lower bound on the size of neural nets that compute it. In addition, we report state of the art results on two benchmark datasets, and show that SpectralNet outperforms existing methods when the clusters cannot be contained in non overlapping convex shapes. We believe the integration of spectral clustering with deep learning provides a useful tool for unsupervised deep learning.
+
+# ACKNOWLEDGEMENTS
+
+We thank Raphy Coifman and Sahand Negahban for helpful discussions. R.B is supported in part by the Minerva foundation with funding from the Federal German Ministry for Education and Research. Y.K and B.N are supported by NIH grant 1R01HG008383-01A1.
+
+# REFERENCES
+
+Carlos Alzate and Johan AK Suykens. Multiway spectral clustering with out-of-sample extensions through weighted kernel pca. IEEE transactions on pattern analysis and machine intelligence, 32 (2):335–347, 2010.
+
+Mikhail Belkin, Partha Niyogi, and Vikas Sindhwani. Manifold regularization: A geometric framework for learning from labeled and unlabeled examples. Journal of machine learning research, 7 (Nov):2399–2434, 2006.
+
+Yoshua Bengio, Jean-franc¸cois Paiement, Pascal Vincent, Olivier Delalleau, Nicolas L Roux, and Marie Ouimet. Out-of-sample extensions for lle, isomap, mds, eigenmaps, and spectral clustering. In Advances in neural information processing systems, pp. 177–184, 2004.
+
+Deng Cai, Xiaofei He, and Jiawei Han. Locally consistent concept factorization for document clustering. IEEE Transactions on Knowledge and Data Engineering, 23(6):902–913, 2011.
+
+Gang Chen. Deep learning with nonparametric clustering. arXiv preprint arXiv:1501.03084, 2015.
+
+Ronald R Coifman and Stephane Lafon. Diffusion maps. ´ Applied and computational harmonic analysis, 21(1):5–30, 2006a.
+
+Ronald R Coifman and Stephane Lafon. Geometric harmonics: a novel tool for multiscale out-of- ´ sample extension of empirical functions. Applied and Computational Harmonic Analysis, 21(1): 31–52, 2006b.
+
+Nat Dilokthanakul, Pedro AM Mediano, Marta Garnelo, Matthew CH Lee, Hugh Salimbeni, Kai Arulkumaran, and Murray Shanahan. Deep unsupervised clustering with gaussian mixture variational autoencoders. arXiv preprint arXiv:1611.02648, 2016.
+
+Kamran Ghasedi Dizaji, Amirhossein Herandi, and Heng Huang. Deep clustering via joint convolutional autoencoder embedding and relative entropy minimization. arXiv preprint arXiv:1704.06327, 2017.
+
+Charless Fowlkes, Serge Belongie, Fan Chung, and Jitendra Malik. Spectral grouping using the nystrom method. IEEE transactions on pattern analysis and machine intelligence, 26(2):214– 225, 2004.
+
+Raia Hadsell, Sumit Chopra, and Yann LeCun. Dimensionality reduction by learning an invariant mapping. In Computer vision and pattern recognition, 2006 IEEE computer society conference on, volume 2, pp. 1735–1742. IEEE, 2006.
+
+Weihua Hu, Takeru Miyato, Seiya Tokui, Eiichi Matsumoto, and Masashi Sugiyama. Learning discrete representations via information maximizing self augmented training. arXiv preprint arXiv:1702.08720, 2017.
+
+Marc T Law, Raquel Urtasun, and Richard S Zemel. Deep spectral clustering learning. In International Conference on Machine Learning, pp. 1985–1994, 2017.
+
+Gal Mishne, Uri Shaham, Alexander Cloninger, and Israel Cohen. Diffusion nets. Applied and Computational Harmonic Analysis, 2017.
+
+James Munkres. Algorithms for the assignment and transportation problems. Journal of the society for industrial and applied mathematics, 5(1):32–38, 1957.
+
+Boaz Nadler, Stephane Lafon, Ioannis Kevrekidis, and Ronald R Coifman. Diffusion maps, spectral clustering and eigenfunctions of fokker-planck operators. In Advances in neural information processing systems, pp. 955–962, 2006.
+
+Andrew Y Ng, Michael I Jordan, and Yair Weiss. On spectral clustering: Analysis and an algorithm. In Advances in neural information processing systems, pp. 849–856, 2002.
+
+Uri Shaham and Roy R Lederman. Learning by coincidence: Siamese networks and common variable learning. Pattern Recognition, 74:52–63, 2018.
+
+Shai Shalev-Shwartz and Shai Ben-David. Understanding machine learning: From theory to algorithms. Cambridge university press, 2014.
+
+Ohad Shamir. A stochastic pca and svd algorithm with an exponential convergence rate. In Proceedings of the 32nd International Conference on Machine Learning (ICML-15), pp. 144–152, 2015.
+
+Jianbo Shi and Jitendra Malik. Normalized cuts and image segmentation. IEEE Transactions on pattern analysis and machine intelligence, 22(8):888–905, 2000.
+
+Fei Tian, Bin Gao, Qing Cui, Enhong Chen, and Tie-Yan Liu. Learning deep representations for graph clustering. In AAAI, pp. 1293–1299, 2014.
+
+Ulrike Von Luxburg. A tutorial on spectral clustering. Statistics and computing, 17(4):395–416, 2007.
+
+Junyuan Xie, Ross Girshick, and Ali Farhadi. Unsupervised deep embedding for clustering analysis. In International Conference on Machine Learning (ICML), 2016.
+
+Bo Yang, Xiao Fu, Nicholas D Sidiropoulos, and Mingyi Hong. Towards k-means-friendly spaces: Simultaneous deep learning and clustering. International Conference on Machine Learning (ICML), 2017.
+
+Jianwei Yang, Devi Parikh, and Dhruv Batra. Joint unsupervised learning of deep representations and image clusters. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 5147–5156, 2016.
+
+Li Yi, Hao Su, Xingwen Guo, and Leonidas Guibas. Syncspeccnn: Synchronized spectral cnn for 3d shape segmentation. arXiv preprint arXiv:1612.00606, 2016.
+
+Yin Zheng, Huachun Tan, Bangsheng Tang, Hanning Zhou, et al. Variational deep embedding: A generative approach to clustering. arXiv preprint arXiv:1611.05148, 2016.
+
+![](images/739b5ebb06c9d939b24aba474a0d11edbae9d0e47657cacb7e3bb6eef34ff190.jpg)  
+Figure 3: SpectralNet performance on the nested $\mathbf { \tilde { C } } \mathbf { \Psi }$ example. Top row: clustering using SpectralNet (left), spectral clustering (center), and $k$ -means (right). Bottom row, left panel: SpectralNet outputs (plotted in blue and green) vs. the true eigenvectors. Bottom row, right panel: loss and Grassmann distance as a function of iteration number; the values on the horizontal axis $\times 1 0 0$ are the numbers of the parameter updates.
+
+# A ILLUSTRATIVE DATASETS
+
+To compare SpectralNet to spectral clustering, we consider a simple dataset of 1500 points in two dimensions, containing two nested $\mathbf { \bar { C } } '$ -shaped clusters. We applied spectral clustering to the dataset by computing the eigenvectors of the unnormalized graph Laplacian $L = D - W$ corresponding to the two smallest eigenvalues, and then applying $k$ -means (with $k { = } 2$ ) to these eigenvector embeddings. The affinity matrix $W$ was computed using $\begin{array} { r } { W _ { i , j } = \exp \left( { - \frac { \| x _ { i } - x _ { j } \| ^ { 2 } } { \sigma ^ { 2 } } } \right) } \end{array}$ , where the scale $\sigma$ was set to be the median distance between a point to its 3rd neighbor – a standard practice in diffusion applications.
+
+Figure 3 shows the clustering of the data obtained by SpectralNet, standard spectral clustering, and $k$ -means. It can be seen that both SpectralNet and spectral clustering identify the correct cluster structure, while $k$ -means fails to do so. Moreover, despite the stochastic training, the net outputs closely approximate the two true eigenvectors of $W$ with smallest eigenvalues. Indeed the Grassmann distance between the net outputs and the true eigenvectors approaches zero as the loss decreases.
+
+In the next experiment, we trained, DCN, VaDE, DEPICT (using agglomerative clustering initialization) and IMSAT (using adversarial perturbations for data augmentation) on the 2D datasets of Figure 1. The experiments were performed using the code published by the authors of each paper. For each method, we tested various network architectures and hyper-parameter settings. Unfortunately, we were unable to find a setting that will yield an appropriate clustering on any of the datasets for DCN, VaDE and DEPICT. IMSAT worked on two out of the five datasets, however failed to yield an appropriate clustering in fairly simple cases. Plots with typical results of each of the methods on each of the five 2D datasets is shown in Figure 4.
+
+To further investigate why these methods fail, we performed a sequence of experiments with the two nested ’C’s data, while changing the distance between the two clusters. The results are shown in Figure 5. We can see that all three methods fail to cluster the points correctly once the clusters cannot be linearly separated.
+
+Interestingly, although the target distribution of DEPICT was initialized with agglomerative clustering, which successfully clusters the nested ’C’s, its target distribution becomes corrupted throughout the training, although its loss is considerably reduced, see Figure 6.
+
+![](images/88632c7ab15857817e7c33daf8c8baf048b3b8ede672c77163311d0296056c46.jpg)  
+Figure 4: from top to bottom: Results of DCN, VaDE, DEPICT and IMSAT on our illustrative datasets.
+
+![](images/cf18cc1727d052768abac2b32cb2d0fb9630b3e3aec7c351045b74fbaa5e1dec.jpg)  
+Figure 5: From top: Typical results of DCN, VaDE, DEPICT and IMSAT on the nested ’C’s, with several different distances between the two clusters.
+
+![](images/545636146f1c96b47d8afd990dc4645e46b0e447502cf4a5485c76f72ae9b66e.jpg)  
+Figure 6: The nested ’C’s, colored by DEPICT target distribution. Left: at initialization (with agglomerative clustering initialization). the DEPICT loss at this stage is 9.01. Right: after DEPICT training. The loss is 0.22. Although the loss decreases with training, the target distribution becomes corrupted.
+
+# B CORRECTNESS OF THE $Q R$ DECOMPOSITION
+
+We next verify that the Cholesky decomposition can indeed be used to compute the QR decomposition of a positive definite matrix. First, observe that since $L$ is lower triangular, then so is $L ^ { - 1 }$ , and $( L ^ { - 1 } ) ^ { T }$ is upper triangular. Hence for $i = 1 , \ldots m$ , the column space of the first $i$ columns of $A$ is the same as the column space of the first $i$ columns of $Q = A ( \dot { L } ^ { - 1 } ) ^ { T }$ . To show that the columns of $Q$ corresponds to Gram-Schmidt orthogonalization of the columns of $A$ , it therefore remains to show that $\hat { Q } ^ { T } Q = I$ . Indeed:
+
+$$
+Q ^ { T } Q = L ^ { - 1 } A ^ { T } A ( L ^ { - 1 } ) ^ { T } = L ^ { - 1 } L L ^ { T } ( L ^ { - 1 } ) ^ { T } = ( L ^ { - 1 } L ) ^ { T } = I .
+$$
+
+# C SECTION 4 PROOFS
+
+# C.1 PRELIMINARIES
+
+To prove Theorem 4.1, we begin with the following definition and lemmas.
+
+Definition C.1 $( \alpha , \beta )$ -separated graph). Let $\alpha > \beta \ge 0$ . An $( \alpha , \beta )$ -separated graph is $G =$ $( V , W )$ , where $V$ has an even number of vertices and has a balanced partition $V = S \cup T$ , $| S | = | T |$ , and $W$ is an affinity matrix so that:
+
+• For any $v _ { i } , v _ { j } \in S$ (resp. $T _ { \cdot }$ ), there is a path $v _ { i } = v _ { k _ { 1 } } , v _ { k _ { 2 } } , \ldots , v _ { k _ { l } } = v _ { j } \in S$ , so that for every two consecutive points $v _ { k _ { l } } , v _ { k _ { l + 1 } }$ along the path, $W _ { k _ { l } , k _ { l + 1 } } \geq \alpha$ .
+
+• For any $v _ { i } \in S , \ v _ { j } \in T , W _ { i , j } \leq \beta .$
+
+Lemma C.2. For any integer $m > 0$ there exists a set ${ \tilde { X } } = \{ x _ { 1 } , \ldots , x _ { m } \} \subseteq \mathbb { R } ^ { d } \left( d \geq 3 \right)$ , so that for any binary partition ${ \tilde { X } } = { \tilde { S } } \cup { \tilde { T } }$ , we can construct a set $X$ of $n = 1 0 m$ points, ${ \tilde { X } } \subset X$ , and $a$ balanced binary partition $X = S \cup T$ , $| S | = | T |$ of it, such that
+
+• $\tilde { S } \subset S , \tilde { T } \subset T$   
+• For any $x _ { i } , x _ { j } \in S \left( r e s p . \ T \right)$ , there is a path $x _ { i } , x _ { k _ { 1 } } , x _ { k _ { 2 } } , \ldots , x _ { k _ { l } } , x _ { j } \in S$ , so that for every two consecutive points $x _ { k _ { l } } , x _ { k _ { l + 1 } }$ along the path, $\| x _ { k _ { l } } - x _ { k _ { l + 1 } } \| \le b < 1$ (property $\pmb { a }$ ).   
+• For any $x _ { i } \in S , \ x _ { j } \in T , \ \| x _ { i } - x _ { j } | \geq 1 ( p r o p e r t y \ b ) .$
+
+Proof. We will prove this for the case $d = 3$ ; the proof holds for any $d \geq 3$ .
+
+Let $m > 0$ be integer. We choose the set $\tilde { X }$ to lie in a 2-dimensional unit grid inside a square of minimal diameter, which is placed in the $Z = 0$ plane. Each point $x _ { i }$ is at a distance 1 from its neighbors.
+
+Next, given a partition of $x _ { 1 } , \ldots , x _ { m }$ to two subsets, $\tilde { S }$ and $\tilde { T }$ , we will construct a set $X \supset { \tilde { X } }$ with $n = 1 0 m$ points and a partition $S \cup T$ that satisfy the conditions of the lemma (an illustration can be seen in Figure 7). First, we add points to obtain a balanced partition. We do so by adding $m$ new points $x _ { m + 1 } , \ldots , x _ { 2 m }$ , assigning each of them arbitrarily to either $\tilde { S }$ or $\tilde { T }$ until $| \tilde { S } | = | \tilde { T } | = m$ . We place all these points also on grid points in the $Z = 0$ plane so that all $2 m$ points lie inside a square of minimal diameter. We further add all the points in $\bar { \tilde { S } }$ to $S$ and those in $\tilde { T }$ to $T$ .
+
+![](images/c8c20b018fdd0d7d18405f40366bb3bc5ae6e66cca2404ba836e6a8bbb3fd305.jpg)  
+Figure 7: Illustration of the construction of Lemma C.2. We select the set $\tilde { X }$ to lie in a grid in the $Z = 0$ plane. Given an arbitrary dichotomy ${ \tilde { X } } = { \tilde { S } } \cup { \tilde { T } }$ (points are marked with filled circles, colored respectively in red and blue), we first add points to make the sets balanced (not shown). Next, we make a copy for $S$ at $Z = 1$ and for $T$ at $Z = - 1$ (filled squares). We then add midpoints between each point and its copy (empty circles), and finally add more points along the minimal length spanning tree (empty squares). Together, all the red points form the set $S$ ; the blue points form the set $T$ , and $X = S \cup T$ .
+
+In the next step, we prepare a copy of the $\tilde { S }$ -points at $Z = 1$ (with the same $X , Y$ coordinates) and a copy of the $\tilde { T }$ -points at $Z = - 1$ . We denote these copies by $x _ { 1 } ^ { \prime } , . . . , x _ { 2 m } ^ { \prime }$ and refer to the lifted points at $Z = 1$ by $S ^ { \prime }$ and at $Z = - 1$ by $T ^ { \prime }$ . Next, we will add $6 m$ more points to make the full set of $n = 1 0 m$ points satisfy properties a and $\mathbf { b }$ . First, we will add the midpoint between every point and its copy, i.e., $x _ { i } ^ { \prime \prime } = ( x _ { i } + x _ { i } ^ { \prime } ) / 2$ . We assign each such midpoint to $S$ (resp. $T$ ) if it is placed between $x _ { i } \in S$ and $x _ { i } ^ { \prime } \in S ^ { \prime }$ (resp. $T$ and $T ^ { \prime }$ ). Then we connect the points in $S ^ { \prime }$ (resp. $T ^ { \prime }$ ) by a minimal length spanning tree and add $4 m$ more points along the edges of these two spanning trees so that the added points are equally spaced along every edge. We assign the new points on the spanning tree of $S ^ { \prime }$ to $S$ and of $T ^ { \prime }$ to $T$ .
+
+We argue that the obtained point set $X$ of size $1 0 m$ satisfies the conditions of the lemma. Clearly, $\tilde { S } \subset \bar { S }$ and $\tilde { T } \subset T$ . To show that property a is satisfied, note that the length of each spanning tree cannot exceed $2 m$ , since the full $2 m$ grid points $\tilde { X }$ can be connected with a tree of length $2 m - 1$ . It is evident therefore that every two points $x _ { i } , x _ { j } \in S$ (resp. $T$ ) are connected by a path in which the distance between each two consecutive points is strictly less than 1 (property a). Property $\mathbf { b }$ too is satisfied because the grid points in $\tilde { X }$ are at least distance 1 apart; each midpoint $x _ { i } ^ { \prime \prime }$ is distance $1 / 2$ from $x _ { i }$ and $\boldsymbol { x } _ { i } ^ { \prime }$ (and they all belong to the same set, either $S$ or $T$ ), but its distance to the rest of the points in $\tilde { X }$ exceeds 1, and the rest of the points in $S$ (resp. $T$ ) are on the $Z = 1$ (resp. $Z = 1$ ) plane, and so they are at least distance 1 away from members of the opposite set which all lie in the $Z \le 0$ (resp. $Z \geq 0$ ) half space. □
+
+Lemma C.3. . Let $f ( \cdot )$ be the spectral clustering loss
+
+$$
+f ( y ) = \sum _ { i , j } W _ { i , j } ( y _ { i } - y _ { j } ) ^ { 2 } .
+$$
+
+Let $G = ( X , W )$ be a $( \alpha , \beta )$ -separated graph, such that $\vert X \vert = n \ge 4$ . Let $y ^ { * }$ be a minimizer of $f ( y ) w . r . t W$ , subject to $1 ^ { T } y = 0 , \ \| y \| = 1$ . Let
+
+and similarly
+
+$$
+\begin{array} { r l } & { \Delta _ { S } = \operatorname* { m a x } \{ y _ { i } ^ { * } - y _ { j } ^ { * } : x _ { i } , x _ { j } \in S \} , } \\ & { } \\ & { \Delta _ { T } = \operatorname* { m a x } \{ y _ { i } ^ { * } - y _ { j } ^ { * } : x _ { i } , x _ { j } \in T \} . } \end{array}
+$$
+
+Let $\Delta = \operatorname* { m a x } \left\{ \Delta _ { S } , \Delta _ { T } \right\}$ . Then
+
+$$
+\frac { \alpha } { \beta } \Delta ^ { 2 } \leq \frac { n ^ { 2 } } { 2 } .
+$$
+
+Proof. Without loss of generality, assume that $x _ { 1 } , \ldots , x _ { \frac { n } { 2 } } \in S$ , $x _ { \frac { n } { 2 } + 1 } , \ldots , x _ { n } \in T$ , and that $y _ { 1 } ^ { * } \leq$ $y _ { 2 } ^ { * } \leq . . . \leq y _ { \frac { n } { 2 } } ^ { * }$ and $y _ { \frac { n } { 2 } + 1 } ^ { * } \leq y _ { \frac { n } { 2 } + 2 } ^ { * } \leq \cdot \cdot \cdot \leq y _ { n } ^ { * }$ . Also wlog, $\Delta = \Delta ^ { \acute { \prime } } s$ . We begin by lower-bounding $f ( y ^ { * } )$ .
+
+$$
+\begin{array} { l } { f ( y ^ { * } ) = \displaystyle \sum _ { i , j } W _ { i , j } ( y _ { i } ^ { * } - y _ { j } ^ { * } ) ^ { 2 } } \\ { \geq \displaystyle \sum _ { x _ { i } , x _ { j } \in S } W _ { i , j } ( y _ { i } ^ { * } - y _ { j } ^ { * } ) ^ { 2 } + \displaystyle \sum _ { x _ { i } , x _ { j } \in T } W _ { i , j } ( y _ { i } ^ { * } - y _ { j } ^ { * } ) ^ { 2 } . } \end{array}
+$$
+
+Since $G$ is $( \alpha , \beta )$ -separated, there exists a path from $y _ { 1 }$ to $y _ { \frac { n } { 2 } }$ (and likewise from $y _ { \frac { n } { 2 } + 1 } ^ { { n } }$ to $y _ { n }$ where the affinity of every pair of consecutive points exceeds $\alpha$ . Denote this path by $\Gamma _ { S }$ (resp. $\Gamma _ { T }$ ), therefore
+
+$$
+f ( \boldsymbol { y } ^ { * } ) \ge \alpha \left( \sum _ { x _ { k _ { i } } , x _ { k _ { i + 1 } } \in \Gamma _ { S } } ( \boldsymbol { y } _ { k _ { i + 1 } } ^ { * } - \boldsymbol { y } _ { k _ { i } } ^ { * } ) ^ { 2 } + \sum _ { x _ { k _ { i } } , x _ { k _ { i + 1 } } \in \Gamma _ { T } } ( \boldsymbol { y } _ { k _ { i + 1 } } ^ { * } - \boldsymbol { y } _ { k _ { i } } ^ { * } ) ^ { 2 } \right) .
+$$
+
+Note that these are telescopic sums of squares. Clearly, such sum of squares is minimized if all $n / 2$ points are ordered and equi-distant, i.e., if we divide a segment of length $\Delta$ into $n / 2 - 1$ segments of equal length. Consequently, discarding the second summand,
+
+$$
+f ( y ^ { * } ) \geq \alpha \left( \frac { n } { 2 } - 1 \right) \left( \frac { \Delta } { n / 2 - 1 } \right) ^ { 2 } = \frac { 2 \Delta ^ { 2 } \alpha } { n - 2 } \geq \frac { 2 \Delta ^ { 2 } \alpha } { n } ,
+$$
+
+Next, to produce an upper bound, we consider the vector $\bar { y } = \textstyle \frac { 1 } { \sqrt { n } } ( - 1 , \dotsc , - 1 , 1 , \dotsc 1 )$ , i.e., $\bar { y } _ { i } =$ $- { \frac { 1 } { \sqrt { n } } }$ for $i \leq \frac { n } { 2 }$ , and $\scriptstyle { \frac { 1 } { \sqrt { n } } }$ otherwise. For this vector,
+
+$$
+f ( \bar { y } ) \leq \beta \left( \frac { n } { 2 } \right) ^ { 2 } \left( \frac { 2 } { \sqrt { n } } \right) ^ { 2 } = n \beta .
+$$
+
+In summary, we obtain
+
+Hence
+
+$$
+\begin{array} { c } { { \displaystyle \frac { 2 \Delta ^ { 2 } \alpha } { n } \leq f ( y ^ { * } ) \leq f ( \bar { y } ) \leq n \beta , } } \\ { { { } } } \\ { { \displaystyle \frac { \alpha } { \beta } \Delta ^ { 2 } \leq \frac { n ^ { 2 } } { 2 } . } } \end{array}
+$$
+
+Lemma C.4. Let $y \in \mathbb { R } ^ { n }$ be a vector such that $1 ^ { T } y ~ = ~ 0$ , and $\| y \| = 1$ . Let $X \ = \ S \cup T$ , $\begin{array} { r } { | S | = | T | = \frac { n } { 2 } } \end{array}$ .
+
+and similarly
+
+$$
+\begin{array} { r l } & { \Delta _ { S } = \operatorname* { m a x } \{ y _ { i } - y _ { j } : x _ { i } , x _ { j } \in S \} , } \\ & { } \\ & { \Delta _ { T } = \operatorname* { m a x } \{ y _ { i } - y _ { j } : x _ { i } , x _ { j } \in T \} . } \end{array}
+$$
+
+Let $\Delta = \operatorname* { m a x } \left\{ \Delta _ { S } , \Delta _ { T } \right\}$ . If $\begin{array} { r } { \Delta < \frac { 1 } { \sqrt { 2 n } } } \end{array}$ , then
+
+$$
+\operatorname* { m a x } \{ y _ { i } : x _ { i } \in S \} < 0 < \operatorname* { m i n } \{ y _ { i } : x _ { i } \in T \} .
+$$
+
+Proof. Let
+
+$$
+m _ { S } = \frac { 2 } { n } \sum _ { x _ { i } \in S } y _ { i } , m _ { T } = \frac { 2 } { n } \sum _ { x _ { i } \in T } y _ { i } .
+$$
+
+Since $1 ^ { T } y = 0$ , we have $m _ { S } = - m _ { T }$ . Without loss of generality, assume that $m _ { S } < 0 < m _ { T }$ . For every $y _ { i }$ such that $x _ { i } \in S$ ,
+
+$$
+( y _ { i } - m _ { S } ) ^ { 2 } \leq \Delta ^ { 2 } .
+$$
+
+Similarly, for every $y _ { i }$ such that $x _ { i } \in T$ ,
+
+$$
+( y _ { i } + m _ { S } ) ^ { 2 } = ( y _ { i } - m _ { T } ) ^ { 2 } \leq \Delta ^ { 2 } .
+$$
+
+This gives
+
+$$
+\begin{array} { r c l } { { } } & { { } } & { { { n \displaystyle \Delta ^ { 2 } \geq \sum _ { x _ { i } \in S } ( y _ { i } - m _ { S } ) ^ { 2 } + \sum _ { x _ { i } \in T } ( y _ { i } + m _ { S } ) ^ { 2 } } } } \\ { { } } & { { } } & { { = \displaystyle \sum _ { x _ { i } \in S \cup T } y _ { i } ^ { 2 } - 2 m _ { S } \sum _ { x _ { i } \in S } y _ { i } + 2 m _ { S } \sum _ { x _ { i } \in T } y _ { i } + n m _ { S } ^ { 2 } } } \\ { { } } & { { } } & { { = 1 - 2 m _ { S } \cdot m _ { S } \frac { n } { 2 } + 2 m _ { S } \cdot - m _ { S } \frac { n } { 2 } + n m _ { S } ^ { 2 } } } \\ { { } } & { { } } & { { = 1 - n m _ { S } ^ { 2 } , } } \end{array}
+$$
+
+which gives
+
+$$
+m _ { S } ^ { 2 } \geq \frac { 1 - n \Delta ^ { 2 } } { n } .
+$$
+
+In order to obtain the desired result, i.e., that $\operatorname* { m a x } \{ y _ { i } : x _ { i } \in S \} < 0 < \operatorname* { m i n } \{ y _ { i } : x _ { i } \in T \}$ , it therefore remains to show that for a sufficiently small $\Delta$ , by (7), $m _ { S } + \Delta < 0$ (this will also yield $m _ { T } - \Delta > 0 ,$ ). Hence, we will require
+
+$$
+{ \frac { 1 - n \Delta ^ { 2 } } { n } } \geq \Delta ^ { 2 } ,
+$$
+
+which holds for $\begin{array} { r } { \Delta < \frac { 1 } { \sqrt { 2 n } } } \end{array}$
+
+# C.2 PROOF OF THEOREM 4.1
+
+Proof. To determine the VC-dimension of $\mathcal { F } _ { n } ^ { \mathrm { s p } }$ ectral clustering we need to show that there exists a set of $m = n / 1 0$ points (assuming for simplicity that $n$ is divisible by 10) that is shattered by spectral clustering. By Lemma C.2, there exists a set of $m$ points $\tilde { X } \subseteq \mathbb { R } ^ { d } \left( d \geq 3 \right)$ so that for any dichotomy of $\tilde { X }$ there exists a set $X \supset { \tilde { X } }$ of $n = 1 0 m$ points, with a balanced partition $X = S \cup T$ that respects the dichotomy of $\tilde { X }$ , and whose points satisfy properties a and $\mathbf { b }$ of Lemma C.2 with $0 \leq b < 1$ .
+
+Consider next the complete graph $G = ( V , W )$ whose vertices $v _ { i } \in V$ correspond to point $x _ { i }$ and the affinity matrix $W$ is set with the standard Gaussian affinity $\begin{array} { r } { W _ { i , j } = \exp \left( { - \frac { \| x _ { i } - x _ { j } \| ^ { 2 } } { 2 \sigma ^ { 2 } } } \right) } \end{array}$ where the value of $\sigma$ will be provided below. It can be readily verified that, due to properties a and $\mathbf { b }$ , $G$ is $( \alpha , \beta )$ -separated, where
+
+$$
+\alpha = \exp \left( - \frac { b ^ { 2 } } { 2 \sigma ^ { 2 } } \right) , \beta = \exp \left( - \frac { 1 } { 2 \sigma ^ { 2 } } \right) .
+$$
+
+Let $y ^ { * }$ be the second-smallest eigenvector of the graph Laplacian matrix for $G$ , i.e., the minimizer of
+
+$$
+f ( y ) = \sum _ { i , j } W _ { i , j } ( y _ { i } - y _ { j } ) ^ { 2 } , \quad \mathrm { s . t . } \quad 1 ^ { T } y = 0 , y ^ { T } y = 1 .
+$$
+
+By Lemma C.3, since $G$ is $( \alpha , \beta )$ -separated, $\Delta$ , i.e, the spread of the entries of $y ^ { * }$ for the partition $S \cup T$ , should satisfy
+
+$$
+\frac { \alpha } { \beta } \Delta ^ { 2 } \leq \frac { n ^ { 2 } } { 2 } .
+$$
+
+Notice that
+
+$$
+\frac { \alpha } { \beta } = \exp \left( \frac { 1 - b ^ { 2 } } { 2 \sigma ^ { 2 } } \right) ,
+$$
+
+allowing us to make $\Delta$ arbitrarily small by pushing the scale $\sigma$ towards $0 ^ { 3 }$ . In particular, we can set $\sigma$ so as to make $\Delta$ satisfy $\Delta < 1 / \sqrt { 2 n }$ . Therefore, by lemma (C.4), thresholding $y ^ { * }$ at 0 respects the partition of $X$ , and hence also the dichotomy of $\tilde { X }$ .
+
+In summary, we have shown that any dichotomy of $\tilde { X }$ can be obtained from a second-smallest eigenvector of some graph Laplacian of $n$ points. Hence the VC dimension of $\mathcal { F }$ is at least $m =$ $n / 1 0$ . □
+
+Table 2: Siamese net and SpectralNet architectures in the MNIST and Reuters experiments.   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Siamese net</td><td rowspan=1 colspan=1>SpectralNet</td></tr><tr><td rowspan=1 colspan=1>MNIST</td><td rowspan=1 colspan=1>ReLU,size=1024ReLU,size = 1024ReLU,size = 512ReLU,size = 10■</td><td rowspan=1 colspan=1>ReLU,size=1024ReLU,size = 1024ReLU,size = 512tanh, size = 10orthonorm</td></tr><tr><td rowspan=1 colspan=1>Reuters</td><td rowspan=1 colspan=1>ReLU, size= 512ReLU,size = 256ReLU,size = 128=</td><td rowspan=1 colspan=1>ReLU, size = 512ReLU, size = 256tanh, size =4orthonorm</td></tr></table>
+
+Table 3: Additional technical details.   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>MNISTSiamese</td><td rowspan=1 colspan=1>MNISTSpectralNet</td><td rowspan=1 colspan=1>ReutersSiamese</td><td rowspan=1 colspan=1>ReutersSpectralNet</td></tr><tr><td rowspan=1 colspan=1>Batch size</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>1024</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>2048</td></tr><tr><td rowspan=1 colspan=1>Ortho.batch size</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>1024</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>2048</td></tr><tr><td rowspan=1 colspan=1>Initial LR</td><td rowspan=1 colspan=1>10-3</td><td rowspan=1 colspan=1>10-3</td><td rowspan=1 colspan=1>10-3</td><td rowspan=1 colspan=1>5·10-5</td></tr><tr><td rowspan=1 colspan=1>LR decay</td><td rowspan=1 colspan=1>.1</td><td rowspan=1 colspan=1>.1</td><td rowspan=1 colspan=1>.1</td><td rowspan=1 colspan=1>.1</td></tr><tr><td rowspan=1 colspan=1>Optimizer</td><td rowspan=1 colspan=1>RMSprop</td><td rowspan=1 colspan=1>RMSprop</td><td rowspan=1 colspan=1>RMSprop</td><td rowspan=1 colspan=1>RMSprop</td></tr><tr><td rowspan=1 colspan=1>Patience epochs</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>10</td></tr></table>
+
+# D TECHNICAL DETAILS
+
+For $k$ -means we used Python’s sklearn.cluster; we used the default configuration (in particular, 300 iterations of the algorithm, 10 restarts from different centroid seeds, final results are from the run with the best objective). To perform spectral clustering, we computed an affinity matrix $W$ using (6), with the number of neighbors set to 25 and the scale $\sigma$ set to the median distance from each point to its $2 5 \mathrm { t h }$ neighbor. Once $W$ was computed, we took the $k$ eigenvectors of $D - W$ corresponding to the smallest eigenvalues, and then applied $k$ -means to that embedding. The $k$ -means configuration was as above. In our experiments, the loss (3) was computed with a factor of $\frac { 1 } { m }$ rather than $\scriptstyle { \frac { 1 } { m ^ { 2 } } }$ , for numerical stability. The architectures of the Siamese net and SpectralNet are described in Table 2. Additional technical details are shown in Table 3.
+
+The learning rate policy for all nets was determined by monitoring the loss on a validation set (a random subset of the training set); once the validation loss did not improve for a specified number of epochs (see patience epochs in Table 3), we divided the learning rate by 10 (see $L R$ decay in Table 3). Training stopped once the learning rate reached $1 0 ^ { - 8 }$ . Typical training took about 100 epochs for a Siamese net and less than 20,000 parameter updates for SpectralNet, on both MNIST and Reuters.
+
+In the MNIST experiments, the training set for the Siamese was obtained by pairing each data point with its two nearest neighbors (in Euclidean distance). During the training of the spectral map, we construct the batch affinity matrix $W$ by connecting each point to its nearest two neighbors in the Siamese distance. The scale $\sigma$ in (6) was set to the median of the distances from each point to its nearest neighbor.
+
+In the Reuters experiment, we obtained the training set for the Siamese net by pairing each point from that set to a random point from its 100 nearest neighbors, found by approximate nearest neighbor algorithm4. To evaluate the generalization performance, the Siamese nets were trained using training data only. The scale $\sigma$ in (6) was set globally to the median (across all points in the dataset) distance from any point to its 10th neighbor.
+
+Finally, we used the validation loss to determine the hyper-parameters. To demonstrate that indeed the validation loss is correlated to clustering accuracy, we conducted a series of experiments with the MNIST dataset, where we varied the net architectures and learning rate policies; the Siamese net and Gaussian scale parameter $\sigma$ were held fixed throughout all experiments. In each experiment, we measured the loss on a validation set and the clustering accuracy (over the entire data). The correlation between loss and accuracy across these experiments was -0.771. This implies that hyperparameter setting for the spectral map learning can be chosen based on the validation loss, and a setup that yields a smaller validation loss should be preferred. We remark that we also use the convergence of the validation loss to determine our learning rate schedule and stopping criterion.

parse/train/Hy7fDog0b/Hy7fDog0b.md

@@ -0,0 +1,404 @@
+# AMBIENTGAN: GENERATIVE MODELS FROM LOSSY MEASUREMENTS
+
+# Eric Price
+
+Ashish Bora Department of Computer Science University of Texas at Austin ashish.bora@utexas.edu
+
+Department of Computer Science University of Texas at Austin ecprice@cs.utexas.edu
+
+Alexandros G. Dimakis   
+Department of Electrical and Computer Engineering   
+University of Texas at Austin   
+dimakis@austin.utexas.edu
+
+# ABSTRACT
+
+Generative models provide a way to model structure in complex distributions and have been shown to be useful for many tasks of practical interest. However, current techniques for training generative models require access to fully-observed samples. In many settings, it is expensive or even impossible to obtain fullyobserved samples, but economical to obtain partial, noisy observations. We consider the task of learning an implicit generative model given only lossy measurements of samples from the distribution of interest. We show that the true underlying distribution can be provably recovered even in the presence of per-sample information loss for a class of measurement models. Based on this, we propose a new method of training Generative Adversarial Networks (GANs) which we call AmbientGAN. On three benchmark datasets, and for various measurement models, we demonstrate substantial qualitative and quantitative improvements. Generative models trained with our method can obtain $2 { - } 4 \mathbf { x }$ higher inception scores than the baselines.
+
+# 1 INTRODUCTION
+
+Generative models are powerful tools to concisely represent the structure in large datasets. An implicit generative model is a mechanism that only specifies a stochastic procedure to produce samples from a probability distribution. These models are attractive since they do not require an explicit parametrization of the probability distribution they are trying to model.
+
+Recently, there has been substantial progress in neural-network based implicit generative models within the autoregressive and the adversarial framework. The adversarial framework was pioneered by Generative Adversarial Networks (GANs) [Goodfellow et al. (2014)]. In these models, a generator network attempts to map samples from a simple low-dimensional distribution (such as standard Gaussian) to points in a high-dimensional space that resemble the learned data distribution. At the same time, a discriminator network attempts to distinguish between real and generated samples. By setting up a min-max game between them, the two networks are jointly trained. The latent probability distribution along with the learned generator network define a stochastic procedure that can produce new samples. The adversarial framework has been shown to be extremely successful in modeling complex distributions [Berthelot et al. (2017); Vondrick et al. (2016); Pascual et al. (2017); Wu et al. (2016)], and the priors induced by these models are useful for various applications [Shrivastava et al. (2016); Ho & Ermon (2016)].
+
+This procedure for training generative models requires access to a large number of fully-observed samples from the desired distribution. Unfortunately, obtaining multiple high-resolution samples can be expensive or impractical for some applications. For example, many sensing and tomography problems (e.g. MRI, CT Scan) require a large number of projections for good reconstruction. Compressed sensing [Donoho (2006); Candes et al. (2006)] attempts to ameliorate this problem using models of the data structure. Recent work has shown that generative models can be particularly effective for easier sensing [Bora et al. (2017); Mardani et al. (2017)]—but if sensing is expensive in the first place, how can we collect enough data to train a generative model to start with?
+
+![](images/51c37674a10740991f2bd1a893a307af611ee97edd1cbd4ef98a023425af46cc.jpg)  
+Figure 1: AmbientGAN training. The output of the generator is passed through a simulated random measurement function $f _ { \Theta }$ . The discriminator must decide if a measurement is real or generated.
+
+This work solves this chicken-and-egg problem by training a generative model directly from noisy or incomplete samples. We show that our observations can be even projections or more general measurements of different types and the unknown distribution is still provably recoverable. A critical assumption for our framework and theory to work is that the measurement process is known and satisfies certain technical conditions.
+
+We present several measurement processes for which it is possible to learn a generative model from a dataset of measured samples, both in theory and in practice. Our approach uses a new way of training GANs, which we call AmbientGAN. The idea is simple: rather than distinguish a real image from a generated image as in a traditional GAN, our discriminator must distinguish a real measurement from a simulated measurement of a generated image; see Figure 1. We empirically demonstrate the effectiveness of our approach on three datasets and a variety of measurement models. Our method is able to construct good generative models from extremely noisy observations and even from low dimensional projections with drastic per-sample information loss. We show this qualitatively by exhibiting samples with good visual quality, and quantitatively by comparing inception scores [Salimans et al. (2016)] to baseline methods.
+
+Theoretical results. We first consider measurements that are noisy, blurred versions of the desired images. That is, we consider convolving the original image with a Gaussian kernel and adding independent Gaussian noise to each pixel (our actual theorem applies to more general kernels and noise distributions). Because of the noise, this process is not invertible for a single image. However, we show that the distribution of measured images uniquely determines the distribution of original images. This implies that a pure Nash equilibrium for the GAN game must find a generative model that matches the true distribution. We show similar results for a dropout measurement model, where each pixel is set to zero with some probability $p$ , and a random projection measurement model, where we observe the inner product of the image with a random Gaussian vector.
+
+Empirical results. Our empirical work also considers measurement models for which we do not have provable guarantees. We present results on some of our models now and defer the full exploration to Section 8.
+
+In Fig. 2, we consider the celebA dataset of celebrity faces [Liu et al. (2015)] under randomly placed occlusions, where a randomly placed square containing $1 / 4$ of the pixels is set to zero. It is hard to inpaint individual images, so cleaning up the data by inpainting and then learning a GAN on the result yields significant artifacts. By incorporating the measurement process into the GAN training, we can produce much better samples.
+
+In Fig. 3a we consider learning from noisy, blurred version of images from the celebA dataset. Each image is convolved with a Gaussian kernel and then IID Gaussian noise is added to each pixel.
+
+![](images/a13d65e89fbc9b3770a321646a003f0ee39f8a9dfe231b0f478d90600a07e3e7.jpg)  
+Figure 2: (Left) Samples of lossy measurements used for training. Samples produced by (middle) a baseline that trains from inpainted images, and (right) our model.
+
+(a) (left) Samples of lossy measurements. Each image is a blurred noisy version of the original. Samples produced by (middle) a baseline that uses Wiener deconvolution, and (right) our model.
+
+![](images/bf0c968b12a9a7bfd6dfcfe3afdcfe3d8cea340b86963bc151d3f4620b633895.jpg)  
+Figure 3: Results with Convolve $^ +$ Noise on celebA (left) and 1D-projections on MNIST (right).
+
+![](images/b28986aaea93b814a4485df540f63b399c089ce755ed9826135a197286bd7b17.jpg)
+
+(b) Samples produced by our model trained from two 1D projections of each image. On left, the training data does not include the angle of the projections, so it cannot identify orientation or chirality. On right, the training data includes the angle.
+
+Learning a GAN on images denoised by Wiener deconvolution leads to poor sample quality while our models are able to produce cleaner samples.
+
+In Fig. 3b, we consider learning a generative model on the 2D images in the MNIST handwritten digit dataset [LeCun et al. (1998)] from pairs of 1D projections. That is, measurements consist of picking two random lines and projecting the image onto each line, so the observed value along the line is the sum of all pixels that project to that point. We consider two variants: in the first, the choice of line is forgotten, while in the second the measurement includes the choice of line. We find for both variants that AmbientGAN recovers a lot of the underlying structure, although the first variant cannot identify the distribution up to rotation or reflection.
+
+# 2 RELATED WORK
+
+There are two distinct approaches to constructing neural network based implicit generative models;   
+autoregressive [Kingma & Welling (2013); Oord et al. (2016b;a)], and adversarial [Goodfellow et al.   
+(2014)]. Some combination approaches have also been successful [Mescheder et al. (2017)].
+
+The adversarial framework has been shown to be extremely powerful in modeling complex data distributions such as images [Radford et al. (2015); Arjovsky et al. (2017); Berthelot et al. (2017)], video [Liang et al. (2017); Vondrick et al. (2016)], and 3D models [Achlioptas et al. (2017); Wu et al. (2016)]. A learned generative model can be useful for many applications. A string of papers [Bora et al. (2017); Zhu et al. (2016); Yeh et al. (2016)] explore the utility of generative priors to solve ill-posed inverse problems. [Shrivastava et al. (2016)] demonstrate that synthetic data can be made more realistic using GANs. [Isola et al. (2016)] and [Zhu et al. (2017)] show how to translate images from one domain to another using GANs.
+
+The idea of operating generators and discriminators on different spaces has been proposed before. [Neyshabur et al. (2017)] explores an interesting connection of training stability with low dimensional projections of samples. They show that training a generator against an array of discriminators, each operating on a different low-dimensional projection of the data can improve stability. Our work is also closely related to [Gadelha et al. (2016)] where the authors create 3D object shapes from a dataset of 2D projections. We note that their setup is a special case of the AmbientGAN framework where the measurement process creates 2D projections using weighted sums of voxel occupancies.
+
+# 3 NOTATION AND OUR APPROACH
+
+Throughout, we use superscript $\cdot _ { r } ,$ to denote real or true distribution, superscript $\dot { \boldsymbol g }$ ’ for the generated distributions, $\cdot _ { x } { \mathrm { : } }$ ’ for the underlying space and $\cdot _ { y } ,$ for measurements. Let $p _ { x } ^ { r }$ be a real underlying distribution over $\mathbb { R } ^ { n }$ . We observe lossy measurements performed on samples from $p _ { x } ^ { r }$ . If we let $m$ be the size of each observed measurement, then, each measurement is an output of some measurement function $f _ { \theta } : \mathbb { R } ^ { n }  \mathbb { R } ^ { m }$ , parameterized by $\theta$ . We allow the measurement function to be stochastic by letting the parameters of the measurement functions have a distribution $p _ { \theta }$ . With this notation, for a given $x$ and $\theta$ , the measurements are given by $y = f _ { \boldsymbol { \theta } } ( \boldsymbol { x } )$ . We assume that it is easy to sample $\Theta \sim p _ { \theta }$ and to compute $f _ { \boldsymbol { \theta } } ( \boldsymbol { x } )$ for any $x$ and $\theta$ . The distributions $p _ { x } ^ { r }$ and $p _ { \theta }$ naturally induce a distribution over the measurements $y$ which we shall denote by $p _ { y } ^ { r }$ . In other words, if $X \sim p _ { x } ^ { r }$ and $\Theta \sim p _ { \theta }$ , then $Y = f _ { \Theta } ( X ) \sim p _ { y } ^ { r }$ .
+
+Our task is the following: there is some unknown distribution $p _ { x } ^ { r }$ and a known distribution $p _ { \theta }$ . We are given a set of IID realizations $\{ y _ { 1 } , y _ { 2 } , \dots , y _ { s } \}$ from the distribution $p _ { y } ^ { r }$ . Using these, our goal is to create an implicit generative model of $p _ { x } ^ { r }$ , i.e., a stochastic procedure that can sample from $p _ { x } ^ { r }$ .
+
+Our main idea is to combine the measurement process with the adversarial training framework, as shown in Fig. 1. Just like in the standard GAN setting, let $Z \in \mathbb { R } ^ { k } , Z \sim p _ { z }$ be a random latent vector for a distribution $p _ { z }$ that is easy to sample from, such as IID Gaussian or IID uniform. Let $G : \mathbb { R } ^ { k }  \mathbb { R } ^ { n }$ be a generator. Let $X ^ { g } = G ( Z )$ , and let $p _ { x } ^ { g }$ be the distribution of $X ^ { g }$ . Thus, our goal is to learn a generator $G$ such that $p _ { x } ^ { g }$ is close to $p _ { x } ^ { r }$ .
+
+However, unlike the standard GAN setting, we do not have access to the desired objects $( X \sim p _ { x } ^ { r } )$ . Instead, we only have a dataset of measurements (samples from $Y \sim p _ { y } ^ { r } )$ . Our main idea is to simulate random measurements on the generated objects $X ^ { g }$ , and use the discriminator to distinguish real measurements from fake measurements. Thus, we sample a random measurement function $f _ { \Theta }$ by sampling $\Theta \sim p _ { \theta }$ and apply it on $X ^ { g }$ to obtain $Y ^ { g } = \bar { { f } _ { \Theta } } ( X ^ { g } ) = f _ { \Theta } ( { G } ( Z ) )$ . Let $p _ { y } ^ { g }$ be the distribution of $Y ^ { g }$ . We set up the discriminator to predict if a given $y$ is a sample from the real measurement distribution $p _ { u } ^ { r }$ as opposed to the generated measurement distribution $p _ { y } ^ { g }$ . Thus, the discriminator is a function $\dot { D } : \mathbb { R } ^ { \dot { m } }  \mathbb { R }$ .
+
+We let $q ( \cdot )$ be the quality function that is used to define the objective, based on the discriminator output. For vanilla GAN, $q ( x ) = \log ( x )$ and for Wasserstein GAN [Arjovsky et al. (2017)], $q ( x ) =$ $x$ . Accordingly, the AmbientGAN objective is the following:
+
+$$
+\operatorname* { m i n } _ { G } \operatorname* { m a x } _ { D } \mathbb { E } _ { Y ^ { r } \sim p _ { y } ^ { r } } [ q ( D ( Y ^ { r } ) ) ] + \mathbb { E } _ { Z \sim p _ { z } , \Theta \sim p _ { \theta } } [ q ( 1 - D ( f _ { \Theta } ( G ( Z ) ) ) ) ] .
+$$
+
+We additionally require $f _ { \theta }$ to be differentiable with respect to its inputs for all $\theta$ . We implement $G$ and $D$ as feedforward neural networks. With these assumptions, our model is end-to-end differentiable and can be trained using an approach similar to the standard gradient-based GAN training procedure. In each iteration, we sample $Z \sim p _ { z }$ , $\Theta \sim p _ { \theta }$ , and $Y ^ { r } \sim \mathrm { U N I F } \{ y _ { 1 } , y _ { 2 } , . . . , y _ { s } \}$ to use them to compute stochastic gradients of the objective with respect to parameters in $G$ and $D$ by backpropagation. We alternate between updates to parameters of $D$ and updates to parameters of $G$ .
+
+We note that our approach is compatible with and complementary to the various improvements proposed to the GAN objective, network architectures, and the training procedures. Additionally, we can easily incorporate additional information, such as per sample labels, in our framework through conditional versions of the generator and discriminator. This is exemplified in our experiments, where we use unconditional and conditional versions of DCGAN [Radford et al. (2015)], unconditional Wasserstein GAN with gradient penalty [Gulrajani et al. (2017)], and an Auxiliary Classifier Wasserstein GAN [Odena et al. (2016)] with gradient penalty.
+
+# 4 MEASUREMENT MODELS
+
+Now, we describe the measurement models that we use for our theoretical and empirical results. We primarily focus on 2D images and thus our measurement models are tailored to this setting. The AmbientGAN learning framework, however, is more general and can be used for other data formats and other measurement models as well. For the rest of this section, we assume that input to the measurement function $( x )$ is a 2D image. We consider the following measurement models:
+
+Block-Pixels: Each pixel is independently set to zero with probability $p$ . Convolve+Noise: Let $k$ be a convolution kernel and let $\Theta \sim p _ { \theta }$ be the distribution of noise. Then the measurements are given by $f _ { \Theta } ( x ) = k * x + \Theta$ , where $^ *$ is the convolution operator. Block-Patch: A randomly chosen $k \times k$ patch is set to zero. Keep-Patch: All pixels outside a randomly chosen $k \times k$ patch are set to zero. Extract-Patch: A random $k \times k$ patch is extracted. Note that unlike the previous measurement function, the information about the location of the patch is lost. Pad-Rotate-Project: We pad the image on all four sides by zeros. Then we rotate the image by a random angle $\mathbf { \eta } ^ { ( \theta ) }$ about its center. The padding is done to make sure that the original pixels stay within the boundary. Finally, for each channel in the image, we sum the pixels along the vertical axis to get one measurement vector. PadRotate-Project- $\theta$ : This is the same as the previous measurement function, except that along with the projection values, the chosen angle is also included in the measurements. Gaussian-Projection: We project onto a random Gaussian vector which is included in the measurements. So, $\Theta \sim \mathcal { N } ( 0 , I _ { n } )$ , and $f _ { \Theta } ( x ) = ( \Theta , \langle \Theta , x \rangle )$ .
+
+# 5 THEORETICAL RESULTS
+
+We show that we can provably recover the true underlying distribution $p _ { x } ^ { r }$ for certain measurement models. Our broad approach is to show that there is a unique distribution $p _ { x } ^ { r }$ consistent with the observed measurement distribution $p _ { y } ^ { r }$ , i.e., the mapping of distributions of samples $p _ { x } ^ { r }$ to distribution of measurements $p _ { y } ^ { r }$ is invertible even though the map from an individual image $x$ to its measurements $f _ { \boldsymbol { \theta } } ( \boldsymbol { x } )$ is not. If this holds, then the following lemma immediately gives a consistency guarantee with the AmbientGAN training procedure.
+
+Lemma 5.1. As in Section 3, let $p _ { x } ^ { r }$ be the data distribution, $p _ { \theta }$ be the distribution over parameters of the measurement functions and $p _ { y } ^ { r }$ be the induced measurement distribution. Further, assume that for the given $p _ { \theta }$ , there is a unique probability distribution $p _ { x } ^ { r }$ that induces the given measurement distribution $p _ { y } ^ { r }$ . Then, for the vanilla GAN model [Goodfellow et al. (2014)], if the Discriminator $D$ is optimal, so that $\begin{array} { r } { D ( \cdot ) = \frac { p _ { y } ^ { r } ( \cdot ) } { p _ { y } ^ { r } ( \cdot ) + p _ { y } ^ { g } ( \cdot ) } } \end{array}$ , then a generator $G$ is optimal iff $p _ { x } ^ { g } = p _ { x } ^ { r }$ .
+
+All proofs including this one are deferred to Appendix A. Note that the previous lemma makes a non-trivial assumption of uniqueness of the true underlying distribution given the measurement distribution. The next few theorems show that this assumption is satisfied under Gaussian-Projection, Convolve $^ +$ Noise and Block-Pixels measurement models, thus showing that that we can recover the true underlying distribution with the AmbientGAN framework.
+
+Theorem 5.2. For the Gaussian-Projection measurement model (Section 4), there is a unique underlying distribution $p _ { x } ^ { r }$ that can induce the observed measurement distribution $p _ { y } ^ { r }$ .
+
+Theorem 5.3. Let $\mathcal F ( \cdot )$ denote the Fourier transform and let $\operatorname { s u p p } ( \cdot )$ be the support of a function. Consider the Convolve $^ +$ Noise measurement model (Section 4) with the convolution kernel $k$ and additive noise distribution $p _ { \theta }$ . If $\operatorname { s u p p } ( \mathcal { F } ( k ) ) ^ { c } = \phi$ and $\operatorname { s u p p } ( \mathcal { F } ( p _ { \theta } ) ) ^ { c } = \phi$ , then there is a unique distribution $p _ { x } ^ { r }$ that can induce the measurement distribution $p _ { y } ^ { r }$ .
+
+We remark that the required conditions in the preceding theorem are easily satisfied for the common setting of Gaussian blurring kernel with additive Gaussian noise. The same guarantee can be generalized for any continuous and invertible function instead of a convolution. We omit the details.
+
+Our next theorem makes an assumption of a finite discrete set of pixel values. This assumption holds in most practical scenarios since images are represented with a finite number of discrete values per channel. In this setting, in addition to a consistency guarantee, we also give a sample complexity result for approximately learning the distributions in the AmbientGAN framework.
+
+Theorem 5.4. Assume that each image pixel takes values in a finite set P. Thus $x \in P ^ { n } \subset \mathbb { R } ^ { n }$ . Assume $0 \in P$ , and consider the Block-Pixels measurement model (Section 4) with $p$ being the probability of blocking a pixel. If $p < 1$ , then there is a unique distribution $p _ { x } ^ { r }$ that can induce the measurement distribution $p _ { y } ^ { r }$ . Further, for any $\epsilon > 0$ , $\delta \in ( 0 , 1 ]$ , given a dataset of
+
+$$
+s = \Omega \left( \frac { | P | ^ { 2 n } } { \left( 1 - p \right) ^ { 2 n } \epsilon ^ { 2 } } \log { \left( \frac { | P | ^ { n } } { \delta } \right) } \right)
+$$
+
+IID measurement samples from $p _ { y } ^ { r }$ , if the discriminator $D$ is optimal, then with probability $\geq 1 - \delta$ over the dataset, any optimal generator $G$ must satisfy $d _ { T V } ( p _ { x } ^ { g } , p _ { x } ^ { r } ) \leq \epsilon$ , where $d _ { T V } ( \cdot , \cdot )$ is the total variation distance.
+
+# 6 DATASETS AND MODEL ARCHITECTURES
+
+We used three datasets for our experiments. MNIST is a dataset of $2 8 \times 2 8$ images of handwritten digits [LeCun et al. (1998)]. CelebA is a dataset of face images of celebrities [Liu et al. (2015)]. We use an aligned and cropped version where each image is $6 4 \times 6 4$ RGB. The CIFAR-10 dataset consists of $3 2 \times 3 2$ RGB images from 10 different classes [Krizhevsky & Hinton (2009)].
+
+We briefly describe the generative models we used for our experiments. More details on architectures and hyperparameters can be found in the appendix. For the MNIST dataset, we use two GAN models. The first model is a conditional DCGAN which follows the architecture in [Radford et al. $( 2 0 1 5 ) ] ^ { 1 }$ , while the second model is an unconditional Wasserstein GAN with gradient penalty (WGANGP) which follows the architecture in [Gulrajani et al. $( 2 0 1 7 ) ] ^ { 2 }$ . For the celebA dataset, we use an unconditional DCGAN and follow the architecture in [Radford et al. $( 2 0 1 5 ) ] ^ { 3 }$ . For the CIFAR-10 dataset, we use an Auxiliary Classifier Wasserstein GAN with gradient penalty (ACWGANGP) which follows the residual architecture in [Gulrajani et al. $( 2 0 1 7 ) ] ^ { 4 }$ .
+
+For measurements with 2D outputs, i.e. Block-Pixels, Block-Patch, Keep-Patch, Extract-Patch, and Convolve $+$ Noise (see Section 4), we use the same discriminator architectures as in the original work. For 1D projections, i.e. Pad-Rotate-Project, Pad-Rotate-Project- $\theta$ , we use fully connected discriminators. The architecture of the fully connected discriminator used for the MNIST dataset was 25-25-1 and for the celebA dataset was 100-100-1.
+
+# 7 BASELINES
+
+Now, we describe some baseline approaches that we implemented to evaluate the relative performance of the AmbientGAN framework. Recall that we have a dataset of IID samples $\{ y _ { 1 } , y _ { 2 } , . . . . y _ { s } \}$ from the measurement distribution $p _ { y } ^ { r }$ and our goal is to create an implicit generative model for $p _ { x } ^ { r }$ .
+
+A crude baseline is to ignore that any measurement happened at all. In other words, for cases where the measurements lie in the same space as the full-samples (for example Convolve+Noise) we can learn a generative model directly on the measurements and test how well it approximates the true distribution $p _ { x } ^ { r }$ . We call this the “ignore” baseline.
+
+A stronger baseline is based on the following observation: If the measurement functions $f _ { \theta }$ were invertible, and we observed $\theta _ { i }$ for each measurement $y _ { i }$ in our dataset, we could just invert the functions to obtain full-samples $x _ { i } = f _ { \theta _ { i } } ^ { - 1 } ( y _ { i } )$ . Then we could directly learn a generative model using these full-samples. Notice that both assumptions are violated in the AmbientGAN setting. First, we may not observe $\theta _ { i }$ and second, the functions may not be invertible. Indeed all the measurement models in Section 4 violate one of the assumptions. However, we can try to approximate an inverse function and use the inverted samples to train a generative model. Thus, given a measurement $y _ { i } = f _ { \boldsymbol { \theta } _ { i } } ( x _ { i } )$ , we try to “unmeasure” it and obtain $\widehat { x } _ { i }$ , an estimate of $x _ { i }$ . We then learn a generative bmodel with the estimated inverse samples and test how well it approximates $p _ { x } ^ { r }$ .
+
+![](images/d20502dc83ca7926d16b6fd2c4cd621065c145c49dd096f2d9b7a0a37eb0e91f.jpg)  
+Figure 4: Results with Block-Pixels on celebA. (left) Samples of lossy measurements. Each pixel is blocked independently with probability $p = 0 . 9 5$ . Samples produced by (middle) unmeasure-blur baseline, and (right) our model.
+
+![](images/e3ace6a56e04f1d401067ba2ef70d66148c3475e4418e1d20de22f705a45806d.jpg)
+
+(a) (left) Samples of lossy measurements. All except a randomly chosen $3 2 \times 3 2$ patch is set to zero. (right) Samples produced by our model.
+
+![](images/1bd8881fd1f6cb91d938ab6218e2a96f539aa0b7b50def00641abf7ce5d3e3fa.jpg)  
+(b) Samples produced by our model with Pad-Rotate-Project- $\theta$ measurements.   
+Figure 5: Results on celebA with (a) Keep-Patch, and (b) 1D projections.
+
+For the measurement models described in Section 4, we now describe the methods we used to obtain approximate inverse functions: (a) For the Block-Pixels measurements, a simple approximate inverse function is to just blur the image so that zero pixels are filled in from the surrounding. We also implemented a more sophisticated approach to fill in the pixels by using total variation inpainting. (b) For Convolve+Noise measurements with a Gaussian kernel and additive Gaussian Noise, we approximate the inverse by a Wiener deconvolution. (c) For Block-Patch measurements, we use the Navier Stokes based inpainting method [Bertalmio et al. (2001)] to fill in the zero pixels.
+
+For other measurement models, it is unclear how to obtain an approximate inverse function. For the Keep-Patch measurement model, no pixels outside a box are known and thus inpainting methods are not suitable. Inverting Extract-Patch measurements is even harder since the information about the position of the patch is also lost. For the Pad-Rotate-Project- $\theta$ measurements, a conventional technique is to sample many angles, and use techniques for inverting the Radon transform [Deans (2007)]. However, since we observe only a few projections at a time, these methods aren’t readily applicable. Inverting Pad-Rotate-Project measurements is even harder since it lacks information about $\theta$ . So, on this subset of experiments, we report only the results with the AmbientGAN models.
+
+# 8 QUALITATIVE RESULTS
+
+We present some samples generated by the baselines and our models. For each experiment, we show the samples from the dataset of measurements $( Y ^ { r } )$ available for training, samples generated by the baselines (when applicable) and the samples generated by our models $( X ^ { g } )$ . We show samples only for a selected value of parameter settings. More results are provided in the appendix. All results on MNIST are deferred to the appendix.
+
+Block-Pixels: Fig. 4 shows results on celebA with DCGAN and Fig. 6 on CIFAR-10 with ACWGANGP. We see that the samples are heavily degraded in our measurement process (left image). Thus, it is challenging for baselines to invert the measurements process, and correspondingly, they do not produce good samples (middle image). Our models are able to produce images with good visual quality (right image).
+
+Convolve+Noise: We use a Gaussian kernel and IID Gaussian noise. Fig. 3a shows results on celebA with DCGAN. We see that the measurements are drowned in noise (left image) and the baselines struggle to extract the original image, giving samples of low quality (middle image). Our models are able to produce samples with clear faces (right image).
+
+![](images/75361c5173e18fbc98f3334d46b893d75d6d5138f3a7078abba97c4b84f9d858.jpg)  
+Figure 6: Results with Block-Pixels on CIFAR-10. (left) Samples of lossy measurements. Each pixel is blocked independently with probability $p = 0 . 8$ . Samples produced by (middle) unmeasure-blur baseline, and (right) our model.
+
+Block-Patch, Keep-Patch: Fig. 2 shows the results for Block-Patch and Fig. 5a for Keep-Patch measurements on celebA with DCGAN. On both measurement distributions, our models are able to create coherent faces (right image) by observing only parts of one image at a time.
+
+1D projections: Pad-Rotate-Project and Pad-Rotate-Project- $\theta$ measurement models exhibit drastic signal degradation; most of the information in a sample is lost during the measurements process. For our experiments, we use two measurements at a time. Fig. 3b shows the results on MNIST with DCGAN. While the first model is able to learn only up to rotation and reflection (left image), we note that generated digits have similar orientations and chirality within each class without any explicit incentive. We hypothesize that the model prefers this mode because it is easier to learn with consistent orientation per class. The second measurement model contains the rotation angle and thus produces upright digits (right image). While in both cases, the generated images are of lesser visual quality, our method demonstrates that we can produce images of digits given only 1D projections.
+
+Failure case: In Fig. 5b, we show the samples obtained from our model trained on celebA dataset with Pad-Rotate-Project- $\cdot \theta$ measurements with a DCGAN. We see that the model has learned a very crude outline of a face, but lacks details. This highlights the difficulty in learning complex distributions with just 1D projections and a need for better understanding of distribution recovery under projection measurement model as well as better methods for training GANs.
+
+# 9 QUANTITATIVE RESULTS
+
+We report inception scores [Salimans et al. (2016)] to quantify the quality of the generative models learned in the AmbientGAN framework. For the CIFAR-10 dataset, we use the Inception model[Szegedy et al. (2016)] trained on the ImageNet dataset [Deng et al. $( 2 0 0 9 ) ] ^ { 1 }$ . For computing a similar score on MNIST, we trained a classification model with two conv+pool layers followed by two fully connected layers2. The final test set accuracy of this model was $9 9 . 2 \%$ .
+
+# 9.1 MNIST
+
+For Block-Pixels measurements on MNIST, we trained several models with our approach and the baselines, each with a different probability $p$ of blocking pixels. For each model, after convergence, we computed the inception score using the network described above. A plot of the inception scores as a function of $p$ is shown in Fig. 7 (left). We note that at $p = 0$ , i.e. if no pixels are blocked, our model is equivalent to a conventional GAN. As we increase $p$ , the baseline models quickly start to perform poorly, while the AmbientGAN models continue to perform relatively well.
+
+![](images/d01f15ed3eae1a255775fecb3efc931f67658bcfc06365b5f8467be528ac4be7.jpg)  
+Figure 7: Results on MNIST with WGANGP. (left) Block-Pixels (right) Convolve+Noise
+
+![](images/caf6bd49ebfdbecfdf4b4bc12e688f2fa0758753cfa2dc0c209d6de8a6134b23.jpg)  
+Figure 8: Quantitative results on CIFAR-10 with ACWGANGP, Block-Pixels measurement. (left) Inception score vs blocking probability $p$ . (right) Inception score vs training iteration with darkness proportional to $1 - p$ . Vertical bars indicate $9 5 \%$ confidence intervals.
+
+For the Convolve+Noise measurements with a Gaussian kernel of radius 1 pixel, and additive Gaussian noise with zero mean and standard deviation $\sigma$ , we trained several models on MNIST by varying the value of $\sigma$ . A plot of the inception score as a function of $\sigma$ is shown in Fig. 7 (right). We see that for small variance of additive noise, Wiener deconvolution and the “ignore” baseline perform quite well. However, as we start to increase the noise levels, these baselines quickly deteriorate in performance, while the AmbientGAN models maintain a high inception score.
+
+For 1D projection measurements, we report the inception scores for the samples produced by the AmbientGAN models trained with two projection measurements at a time. The Pad-Rotate-Project model produces digits at various orientations and thus does quite poorly, achieving an inception score of just 4.18. The model with Pad-Rotate-Project- $\cdot \theta$ measurements produces well-aligned digits and achieves an inception score of 8.12. For comparison, the vanilla GAN model trained with fullyobserved samples achieves an inception score of 8.99. Thus, the second model comes quite close to the performance of the fully-observed case while being trained only on 1D projections.
+
+# 9.2 CIFAR-10
+
+In Fig. 8 (left), we show a plot of inception score vs the probability of blocking pixels $p$ in the BlockPixels measurement model on CIFAR-10. We note that the total variation inpainting method is quite slow and the performance on MNIST was about the same as unmeasure-blur baseline. So, we do not run inpainting baselines on the CIFAR-10 dataset. From the plots, we see a trend similar to the plot obtained with MNIST (Fig. 7, left), showing the superiority of our approach over baselines. We show the inception score as a function of training iteration in Fig. 8 (right).
+
+# 10 CONCLUSION
+
+Generative models are powerful tools, but constructing a generative model requires a large, highquality dataset of the distribution of interest. We show how to relax this requirement, by learning a distribution from a dataset that only contains incomplete, noisy measurements of the distribution. We hope that this will allow for the construction of new generative models of distributions for which no high-quality dataset exists.
+
+# ACKNOWLEDGEMENTS
+
+We would like to thank Philipp Krahenb ¨ uhl, Ajil Jalal, Surbhi Goel, and Jessica Hoffmann for ¨ helpful discussions. This research has been supported by NSF Grants CCF 1407278, 1422549, 1618689, DMS 1723052, ARO YIP W911NF-14-1-0258 and NVIDIA Corporation.
+
+# REFERENCES
+
+Panos Achlioptas, Olga Diamanti, Ioannis Mitliagkas, and Leonidas Guibas. Representation learning and adversarial generation of 3d point clouds. arXiv preprint arXiv:1707.02392, 2017.   
+Martin Arjovsky, Soumith Chintala, and Leon Bottou. Wasserstein gan. ´ arXiv preprint arXiv:1701.07875, 2017.   
+Marcelo Bertalmio, Andrea L Bertozzi, and Guillermo Sapiro. Navier-stokes, fluid dynamics, and image and video inpainting. In Computer Vision and Pattern Recognition, 2001. CVPR 2001. Proceedings of the 2001 IEEE Computer Society Conference on, volume 1, pp. I–I. IEEE, 2001.   
+David Berthelot, Tom Schumm, and Luke Metz. Began: Boundary equilibrium generative adversarial networks. arXiv preprint arXiv:1703.10717, 2017.   
+Ashish Bora, Ajil Jalal, Eric Price, and Alexandros G Dimakis. Compressed sensing using generative models. arXiv preprint arXiv:1703.03208, 2017.   
+Emmanuel J Candes, Justin K Romberg, and Terence Tao. Stable signal recovery from incomplete and inaccurate measurements. Communications on pure and applied mathematics, 59(8):1207– 1223, 2006.   
+Harald Cramer and Herman Wold. Some theorems on distribution functions. ´ Journal of the London Mathematical Society, 1(4):290–294, 1936.   
+Stanley R Deans. The Radon transform and some of its applications. Courier Corporation, 2007.   
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In Computer Vision and Pattern Recognition, 2009. CVPR 2009. IEEE Conference on, pp. 248–255. IEEE, 2009.   
+David L Donoho. Compressed sensing. IEEE Transactions on information theory, 52(4):1289– 1306, 2006.   
+Matheus Gadelha, Subhransu Maji, and Rui Wang. 3d shape induction from 2d views of multiple objects. arXiv preprint arXiv:1612.05872, 2016.   
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pp. 2672–2680, 2014.   
+Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron Courville. Improved training of wasserstein gans. arXiv preprint arXiv:1704.00028, 2017.   
+Jonathan Ho and Stefano Ermon. Generative adversarial imitation learning. In Advances in Neural Information Processing Systems, pp. 4565–4573, 2016.   
+Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A Efros. Image-to-image translation with conditional adversarial networks. arXiv preprint arXiv:1611.07004, 2016.   
+Diederik $\mathrm { \bf P }$ Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013.   
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.   
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.   
+Xiaodan Liang, Lisa Lee, Wei Dai, and Eric P Xing. Dual motion gan for future-flow embedded video prediction. arXiv preprint arXiv:1708.00284, 2017.   
+Ziwei Liu, Ping Luo, Xiaogang Wang, and Xiaoou Tang. Deep learning face attributes in the wild. In Proceedings of the IEEE International Conference on Computer Vision, pp. 3730–3738, 2015.   
+Morteza Mardani, Enhao Gong, Joseph Y Cheng, Shreyas Vasanawala, Greg Zaharchuk, Marcus Alley, Neil Thakur, Song Han, William Dally, John M Pauly, et al. Deep generative adversarial networks for compressed sensing automates mri. arXiv preprint arXiv:1706.00051, 2017.   
+Lars Mescheder, Sebastian Nowozin, and Andreas Geiger. Adversarial variational bayes: Unifying variational autoencoders and generative adversarial networks. arXiv preprint arXiv:1701.04722, 2017.   
+Behnam Neyshabur, Srinadh Bhojanapalli, and Ayan Chakrabarti. Stabilizing gan training with multiple random projections. arXiv preprint arXiv:1705.07831, 2017.   
+Augustus Odena, Christopher Olah, and Jonathon Shlens. Conditional image synthesis with auxiliary classifier gans. arXiv preprint arXiv:1610.09585, 2016.   
+Aaron van den Oord, Sander Dieleman, Heiga Zen, Karen Simonyan, Oriol Vinyals, Alex Graves, Nal Kalchbrenner, Andrew Senior, and Koray Kavukcuoglu. Wavenet: A generative model for raw audio. arXiv preprint arXiv:1609.03499, 2016a.   
+Aaron van den Oord, Nal Kalchbrenner, and Koray Kavukcuoglu. Pixel recurrent neural networks. arXiv preprint arXiv:1601.06759, 2016b.   
+Santiago Pascual, Antonio Bonafonte, and Joan Serra. Segan: Speech enhancement generative \` adversarial network. arXiv preprint arXiv:1703.09452, 2017.   
+Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. arXiv preprint arXiv:1511.06434, 2015.   
+Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. In Advances in Neural Information Processing Systems, pp. 2234–2242, 2016.   
+Ashish Shrivastava, Tomas Pfister, Oncel Tuzel, Josh Susskind, Wenda Wang, and Russ Webb. Learning from simulated and unsupervised images through adversarial training. arXiv preprint arXiv:1612.07828, 2016.   
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2818–2826, 2016.   
+Carl Vondrick, Hamed Pirsiavash, and Antonio Torralba. Generating videos with scene dynamics. In Advances In Neural Information Processing Systems, pp. 613–621, 2016.   
+Jiajun Wu, Chengkai Zhang, Tianfan Xue, Bill Freeman, and Josh Tenenbaum. Learning a probabilistic latent space of object shapes via 3d generative-adversarial modeling. In Advances in Neural Information Processing Systems, pp. 82–90, 2016.   
+Raymond Yeh, Chen Chen, Teck Yian Lim, Mark Hasegawa-Johnson, and Minh N Do. Semantic image inpainting with perceptual and contextual losses. arXiv preprint arXiv:1607.07539, 2016.
+
+Jun-Yan Zhu, Philipp Krahenb ¨ uhl, Eli Shechtman, and Alexei A Efros. Generative visual manipu- ¨ lation on the natural image manifold. In European Conference on Computer Vision, pp. 597–613. Springer, 2016.
+
+Jun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. arXiv preprint arXiv:1703.10593, 2017.
+
+# APPENDIX A
+
+# 10.1 PROOF OF LEMMA 5.1
+
+Lemma. As in Section 3, let $p _ { x } ^ { r }$ be the data distribution, $p _ { \theta }$ be the distribution over parameters of the measurement functions and $p _ { y } ^ { r }$ be the induced measurement distribution. Further, assume that for the given $p _ { \theta }$ , there is a unique probability distribution $p _ { x } ^ { r }$ that induces the given measurement distribution $p _ { y } ^ { r }$ . Then, for the vanilla GAN model [Goodfellow et al. (2014)], if the Discriminator $D$ is optimal, so that
+
+$$
+D ( \cdot ) = \frac { p _ { y } ^ { r } ( \cdot ) } { p _ { y } ^ { r } ( \cdot ) + p _ { y } ^ { g } ( \cdot ) } ,
+$$
+
+then a generator $G$ is optimal iff $p _ { x } ^ { g } = p _ { x } ^ { r }$
+
+Proof. From the same argument as in Theorem 1 in [Goodfellow et al. (2014)], it follows that $p _ { y } ^ { g } =$ $p _ { y } ^ { r }$ . Then, since there is a unique probability distribution $p _ { x } ^ { r }$ that can induce the given measurement distribution, it follows that $p _ { x } ^ { g } = p _ { x } ^ { r }$ . The converse is trivially true. □
+
+# 10.2 PROOF OF THEOREM 5.2
+
+Theorem. For the Gaussian-Projection measurement model (Section 4), there is a unique underlying distribution $p _ { x } ^ { r }$ that can induce the observed measurement distribution $p _ { y } ^ { r }$ .
+
+Proof. We note that Since $\Theta \sim \mathcal { N } ( 0 , I _ { n } )$ , all possible directions for projections are covered. Further, since the measurement model includes the projection vector $\Theta$ as a part of the measurements, in order to match the measurement distribution, the underlying distribution $p _ { x } ^ { r }$ must be such that all 1D marginals are matched. Thus, by Cramer-Wold theorem [Cramer & Wold (1936)], any sequence ´ of random vectors that match the 1D marginals must converge in distribution to the true underlying distribution. Thus, in particular, there is a unique probability distribution $p _ { x } ^ { r }$ that can match all 1D marginals obtained with the Gaussian projection measurements. □
+
+# 10.3 PROOF OF THEOREM 5.3
+
+Theorem. Let $\mathcal F ( \cdot )$ denote the Fourier transform and let $\operatorname { s u p p } ( \cdot )$ be the support of a function. Consider the Convolve+Noise measurement model (Section 4) with the convolution kernel $k$ and additive noise distribution $p _ { \theta }$ . If $\operatorname { s u p p } ( \mathcal { F } ( k ) ) ^ { c } = \phi$ and $\operatorname { s u p p } ( \mathcal { F } ( p _ { \theta } ) ) ^ { c } = \phi$ , then there is a unique distribution $p _ { x } ^ { r }$ that can induce the measurement distribution $p _ { y } ^ { r }$ .
+
+Proof. Let $X \sim p _ { x }$ . Let $\Theta \sim p _ { \theta }$ . Let $Z = k * X$ so that $Z \sim p _ { z }$ , and $Y = Z + \Theta$ , so $Y \sim p _ { y }$ . With a slight abuse of notation, we will denote the probability density functions (pdf) also by $p$ subscripted with the variable name. Then we have
+
+$$
+\begin{array} { r l } & { \quad \quad Z = k * X , } \\ & { \Leftrightarrow \mathcal { F } ( Z ) = \mathcal { F } ( k ) \mathcal { F } ( X ) , } \\ & { \Leftrightarrow \mathcal { F } ( X ) = \mathcal { F } ( Z ) / \mathcal { F } ( k ) , } \\ & { \quad \quad \Leftrightarrow X = \mathcal { F } ^ { - 1 } ( \mathcal { F } ( Z ) / \mathcal { F } ( k ) ) , } \end{array}
+$$
+
+where the penultimate step follows since by assumption, $\mathcal { F } ( k )$ is nowhere 0. In the last step, ${ \mathcal { F } } ^ { - 1 }$ is the inverse Fourier transform.
+
+Thus, there is a bijective map between $X$ and $Z$ . Since the Fourier and the inverse Fourier are continuous transformations, this map is also continuous. So, we can write $Z = h ( X )$ , where $h$ is a bijective, differentiable function. So, the pdfs of $X$ and $Z$ are related as
+
+$$
+p _ { x } ( \cdot ) = p _ { z } ( h ( \cdot ) ) \left| { \operatorname* { d e t } ( J _ { h } ( \cdot ) ) } \right| ,
+$$
+
+where $J _ { h } ( \widetilde { x } )$ is the Jacobian of $h$ evaluated at $\tilde { x }$
+
+Now, note that since Y is a sum of two random variables, its pdf is a convolution of the individual probability density functions. So we have:
+
+$$
+p _ { y } = p _ { z } * p _ { \theta }
+$$
+
+Taking the Fourier transform on both sides, we have
+
+$$
+\begin{array} { r l } & { \mathcal { F } ( { p _ { y } } ) = \mathcal { F } ( { p _ { z } } ) \mathcal { F } ( { p _ { \theta } } ) , } \\ & { \Leftrightarrow \mathcal { F } ( { p _ { z } } ) = \mathcal { F } ( { p _ { y } } ) / \mathcal { F } ( { p _ { \theta } } ) , } \\ & { \qquad \Leftrightarrow p _ { z } = \mathcal { F } ^ { - 1 } ( \mathcal { F } ( { p _ { y } } ) / \mathcal { F } ( { p _ { \theta } } ) ) , } \end{array}
+$$
+
+where the penultimate step follows since by assumption, $\mathcal { F } ( p _ { \theta } )$ is nowhere 0.
+
+Combining the two results, we have a reverse map from the measurement distribution $p _ { y }$ to a sample distribution $p _ { x }$ . Thus, the reverse map uniquely determines the true underlying distribution $p _ { x }$ , concluding the proof. □
+
+# 10.4 PROOF OF THEOREM 5.4
+
+We first state a slightly different version of Theorem 1 from [Goodfellow et al. (2014)] for the discrete setting. We shall use $[ n ]$ to denote the set $\{ 1 , 2 , \ldots n \}$ , and use $\mathbb { I } ( \cdot )$ to denote the indicator function.
+
+Lemma 10.1. Consider a dataset of measurement samples $\left\{ y _ { 1 } , y _ { 2 } , \dots y _ { s } \right\}$ , where each $y _ { i } \in [ t ]$ . We define the empirical version of the vanilla GAN objective as
+
+$$
+\operatorname* { m i n } _ { G } \operatorname* { m a x } _ { D } \frac { 1 } { s } \sum _ { i = 1 } ^ { s } \log ( D ( y _ { i } ) ) + \mathbb { E } _ { Y ^ { g } \sim p _ { y } ^ { g } } [ \log ( 1 - D ( Y ^ { g } ) ) ] .
+$$
+
+For $j \in [ t ]$ , let $\hat { p } _ { y } ^ { r } ( j ) = \sum \mathbb { I } ( y _ { i } = j ) / s$ be the empirical distribution of samples. Then the optimal discriminator for the empirical objective is such that
+
+$$
+D ( \cdot ) = \frac { \hat { p } _ { y } ^ { r } ( \cdot ) } { \hat { p } _ { y } ^ { r } ( \cdot ) + p _ { y } ^ { g } ( \cdot ) } .
+$$
+
+Additionally, if we fix the discriminator to be optimal, then any optimal generator must satisfy $p _ { y } ^ { g } = \hat { p } _ { y } ^ { r }$ .
+
+Proof. The Empirical Risk Minimization (ERM) version of the loss is equivalent to the taking expectation of the data dependent term with respect to the empirical distribution. Replacing the real data distribution with the empirical version in the proof of Theorem 1 from [Goodfellow et al. (2014)], we obtain the result. □
+
+Now we give a proof of Theorem 5.4.
+
+Theorem. Assume that each image pixel takes values in a finite set P. Thus $x \in P ^ { n } \subset \mathbb { R } ^ { n }$ . Assume $0 \in P$ , and consider the Block-Pixels measurement model (Section 4) with $p$ being the probability of blocking a pixel. If $p < 1$ , then there is a unique distribution $p _ { x } ^ { r }$ that can induce the measurement distribution $p _ { y } ^ { r }$ . Further, for any $\epsilon > 0$ , $\delta \in ( 0 , 1 ]$ , given a dataset of
+
+$$
+s = \Omega \left( \frac { | P | ^ { 2 n } } { { ( 1 - p ) } ^ { 2 n } \epsilon ^ { 2 } } \log { \left( \frac { | P | ^ { n } } { \delta } \right) } \right)
+$$
+
+IID measurement samples from $p _ { y } ^ { r }$ , if the discriminator $D$ is optimal, then with probability $\geq 1 - \delta$ over the dataset, any optimal generator $G$ must satisfy $d _ { T V } ( p _ { x } ^ { g } , p _ { x } ^ { r } ) \leq \epsilon$ , where $d _ { T V } ( \cdot , \cdot )$ is the total variation distance.
+
+Proof. We first consider a more general case and apply that to the Block-Pixels model. Consider a discrete distribution $p _ { x }$ over $[ t ]$ . We apply random measurement functions to samples from $p _ { x }$ to obtain measurements. Assume that each measurement also belongs to the same set, i.e. $[ t ]$ . Let $A \ \in \ \mathbb { R } ^ { t \times t }$ be the transition matrix so that $A _ { i j }$ is the probability (under the randomness in measurement functions) that measurement $i$ was produced by sample $j$ . Then the distribution over measurements $p _ { y }$ can be written in terms of $p _ { x }$ and $A$ as:
+
+$$
+p _ { y } = A p _ { x }
+$$
+
+Thus, if the matrix $A$ is invertible, we can guarantee that the distribution $p _ { x }$ is recoverable from $p _ { y }$
+
+Assuming $A$ is invertible, we now turn to the sample complexity. Let $\lambda$ be the minimum of magnitude of eigenvalues of $A$ . Since $A$ is invertible, $\lambda > 0$ . Let the dataset of measurements be $\left\{ y _ { 1 } , y _ { 2 } , \dots y _ { s } \right\}$ . For $j \in [ t ]$ and for $k \in [ s ]$ , Let $Y _ { k } ^ { j } = \mathbb { I } ( y _ { k } = j )$ . Then for any $\epsilon > 0$ , we have
+
+$$
+\begin{array} { r l } { \mathbb { E } \left( \left| | \hat { \nu } _ { y } ^ { \star } - \bar { p } _ { y } ^ { \star } | \right| \geq \frac { \lambda ^ { 2 } \epsilon ^ { 2 } } { t } \right) = } & { \mathbb { E } \left( \displaystyle \sum _ { i = 1 } ^ { t } \bar { ( \hat { \nu } _ { y } ^ { \star } ( j ) - p _ { i } ^ { \star } ( j ) ) ^ { 2 } } \geq \frac { \lambda ^ { 2 } \epsilon ^ { 2 } } { t } \right) , } \\ & { \leq \mathbb { E } \left( \displaystyle \sum _ { i = 1 } ^ { t } \left( \bar { ( \hat { \nu } _ { y } ^ { \star } ( j ) - p _ { i } ^ { \star } ( j ) ) ^ { 2 } } \geq \frac { \lambda ^ { 2 } \epsilon ^ { 2 } } { \lambda ^ { 2 } } \right) \right) , } \\ & { \leq \displaystyle \sum _ { i = 1 } ^ { t } \mathbb { E } \left( | | \hat { \nu } _ { y } ^ { \star } ( j ) - p _ { i } ^ { \star } ( j ) | \geq \frac { \lambda ^ { 2 } } { t } \right) , } \\ & { = \displaystyle \sum _ { j = 1 } ^ { t } \mathbb { E } \left( \left| \sum _ { i = 1 } ^ { t } \bar { \lambda } _ { i } ^ { j } - p _ { i } ^ { \star } ( j ) \right| \geq \frac { \lambda ^ { 2 } } { t } \right) , } \\ & { \leq \displaystyle \sum _ { j = 1 } ^ { t } \exp \left( | \sum _ { i = 1 } ^ { t } \bar { \lambda } _ { i } ^ { j } - p _ { i } ^ { \star } ( j ) | \right) \lesssim \frac { \lambda ^ { 2 } } { t } \int _ { 0 } ^ { t } \int _ { 0 } ^ { t } \int _ { 0 } ^ { t } \hat { \nu } ( j ) , } \\ & { \leq \displaystyle \sum _ { j = 1 } ^ { t } \exp ( - 2 \lambda \hat { \nu } _ { i } ^ { 2 } \epsilon ^ { 2 } j ) ^ { 2 } , } \\ & { = 2 \exp ( - 2 \lambda \hat { \nu } _ { i } ^ { 2 } \epsilon ^ { 2 } j ) . } \end{array}
+$$
+
+where we used union bound and Chernoff inequalities. Setting this to $\delta$ , we get
+
+$$
+s = \frac { t ^ { 2 } } { 2 \lambda ^ { 2 } \epsilon ^ { 2 } } \log \left( \frac { 2 t } { \delta } \right) .
+$$
+
+From Lemma 10.1, we know that the optimal generator must satisfy $p _ { y } ^ { g } = \hat { p } _ { y } ^ { r }$ . By invertibility of $A$ , we know that $p _ { x } ^ { g } = A ^ { - 1 } p _ { y } ^ { g }$ , and that $p _ { x } ^ { r } = A ^ { - 1 } p _ { y } ^ { r }$ . Thus, we obtain that with probability $\geq 1 - \delta$ ,
+
+$$
+\begin{array} { r l } { 2 d _ { T V } ( p _ { z } ^ { \theta } , p _ { x } ^ { \theta ^ { \prime } } ) = \| p _ { x } ^ { \theta } - p _ { x } ^ { \theta ^ { \prime } } \| _ { 0 } , } & { } \\ & { \leq \sqrt { t } \| p _ { x } ^ { \theta ^ { \prime } } - p _ { x } ^ { \theta ^ { \prime } } \| _ { 2 } , } \\ & { = \sqrt { t } \| A ^ { - } \boldsymbol { b } _ { y } ^ { \theta ^ { \prime } } - p _ { x } ^ { \theta ^ { \prime } } \| _ { 2 } , } \\ & { = \sqrt { t } \| A ^ { - } \boldsymbol { b } _ { y } ^ { \theta ^ { \prime } } - p _ { x } ^ { \theta ^ { \prime } } \| _ { 2 } , } \\ & { = \sqrt { t } \| A ^ { - 1 } ( p _ { y } ^ { \theta ^ { \prime } } + \bar { p } _ { y } ^ { \theta ^ { \prime } } - p _ { y } ^ { \theta ^ { \prime } } ) - p _ { x } ^ { \theta ^ { \prime } } \| _ { 2 } , } \\ & { = \sqrt { t } \| p _ { x } ^ { \theta } + A ^ { - 1 } ( \bar { p } _ { y } ^ { \theta ^ { \prime } } - p _ { y } ^ { \theta ^ { \prime } } ) - p _ { z } ^ { \theta ^ { \prime } } \| _ { 2 } , } \\ & { \leq \sqrt { t } \| A ^ { - 1 } \| _ { 2 } \| \bar { p } _ { y } ^ { \theta ^ { \prime } } - p _ { y } ^ { \theta ^ { \prime } } \| _ { 2 } , } \\ & { \leq \sqrt { t } \frac { 1 } { \lambda } \frac { \lambda \epsilon } { \sqrt { t } } , } \\ & { = \epsilon , } \end{array}
+$$
+
+Now we turn to the specific case of Block-Pixels measurement. We proceed by dividing the set of all possible $| P | ^ { n }$ images into $n + 1$ classes. The $i \cdot$ -th class has those images that have exactly $i$ pixels with zero value. We sort the images according to their class number (arbitrary ordering within the class) and consider the transition matrix $A$ . Note that given an image from class $i$ it must have $j \geq i$ zero pixels after the measurement. Also, no image in class $i$ can produce another image in the same class after measurements. Thus, the transition matrix is lower triangular.
+
+Since each pixel is blocked independently with probability $p$ and since there are $n$ pixels, the event that no pixels are blocked occurs with probability $\left( 1 - p \right) ^ { n }$ . Thus, every image has at least $\left( 1 - p \right) ^ { n }$ chance of being unaffected by the measurements. Any unaffected image maps to itself and thus forms diagonal entries in the transition matrix. So, we observe that the diagonal entries of the transition matrix are strictly positive and their minimum value is $\left( 1 - p \right) ^ { n }$ .
+
+For a triangular matrix, the diagonal entries are precisely the eigenvalues and hence we have proved that $A$ is invertible and the smallest eigenvalue is $( 1 { \overset { \cdot } { - } } p ) ^ { n }$ . Combined with the result above, by setting $\lambda = ( 1 - p ) ^ { n }$ , and $t = | P | ^ { n }$ , we conclude the proof.
+
+# APPENDIX B
+
+# 10.5 MODEL ARCHITECTURE DETAILS
+
+The DCGAN model on MNIST follows the architecture in [Radford et al. (2015)]. The noise input to the generator $( Z )$ has 100 dimensions where each coordinate is sampled IID Uniform on $[ - 1 , 1 ]$ . The generator uses two linear layers followed by two deconvolutional layers. The labels are concatenated with the inputs of each layer. The discriminator uses two convolutional layers followed by two linear layers. As with the generator, the labels are concatenated with the inputs of each layer. Batch-norm is used in both generator and the discriminator.
+
+The WGANGP model on MNIST follows the architecture in [Gulrajani et al. (2017)]. The generator takes in a latent vector of 128 dimensions where each coordinate is sampled IID Uniform on $[ - 1 , 1 ]$ . The generator then applies one linear and three deconvolutional layers. The discriminator uses three convolutional layers followed by one linear layer. Batch-norm is not used.
+
+The unconditional DCGAN model on celebA follows the architecture in [Radford et al. (2015)]. The latent vector has 100 dimensions where each coordinate is Uniform on $[ - 1 , 1 ]$ . The generator applies one linear layer followed by four deconvolutional layers. The discriminator uses four convolutional layers followed by a linear layer. Batch-norm is used in both generator and the discriminator.
+
+The ACWGANGP model on CIFAR-10 follows the residual architecture in [Gulrajani et al. (2017)]. The latent vector has 128 dimensions where each coordinate is sampled from IID standard Gaussian distribution. The generator has a linear layer followed by three residual blocks. Each residual block consists of two repetitions of the following three operations: conditional batch normalization followed by a nonlinearity followed by an upconvolution layer. The residual blocks are followed by another conditional batch normalization, a final convolution, and a final tanh non-linearity. The discriminator consists of one residual block with two convolutional layers followed by three residual blocks, and a final linear layer.
+
+# APPENDIX C
+
+Here, we present some more results for various measurement models.
+
+![](images/ca7d06add2dfe80f231edc8a658745c4533b88b44935c836971a3e73f33713e8.jpg)  
+Figure 9: Results on MNIST with (a) Keep-Patch, and (b) Extract-Patch
+
+![](images/c5b12e085f576ef22d46caec7cca7183e549a6388d8f8107ea1b90e57b867b81.jpg)  
+Figure 10: Results with Convolve+Noise on MNIST. Each image is blurred with a Gaussian kernel of radius 1 pixel and noise of std dev $\sigma$ is added. Rows from top to bottom have $\sigma = 0 . 0$ , 0.1, 0.2, and 0.5 respectively. Columns from left to right are: (1) Samples of lossy measurements. (2) Samples produced by ignore baseline. (3) Samples produced by unmeasure-wiener-deconvolution baseline. (4) Samples produced by our model.
+
+![](images/f6cf191d70deb607a85f427333ec6a0581f3aa269a992cdeca12b264a59eaaea.jpg)  
+Figure 11: Results with Block-Pixels on MNIST. Rows from top to bottom have blocking probability 0.1, 0.5, 0.8, 0.9, 0.95 and 0.99 respectively. Columns from left to right are: (1) Samples of lossy measurements. (2) Samples produced by unmeasure-blur baseline. (3) Samples produced by unmeasure-inpaint-total-variation baseline. (4) Samples produced by our model.
+
+![](images/598e9bf15f2976333e628b0c3515b8d086624e240c50a6a350c5d6db0bd00321.jpg)  
+Figure 12: Results with Block-Patch on MNIST. (left) Samples of lossy measurements. A randomly chosen $1 4 \times 1 4$ patch is set to zero. (middle) Samples produced by unmeasure-navier-stokesinpainting baseline. (right) Samples produced by the our model.
+
+![](images/8e787131d99403a6eac017a3188005f1ed0fc521dc0acba534fd1cda9ed88ef4.jpg)  
+Figure 13: Results with Convolve+Noise on celebA. Each image is blurred with a Gaussian kernel of radius 1 pixel and noise of std dev $\sigma$ is added. Rows from top to bottom have $\sigma = 0 . 0$ , 0.1, and 0.2 respectively. The left column shows samples of lossy measurements. The right column shows samples produced by our model.
+
+![](images/1129973e5b8c1e39e867b6c0018b3e34038ce4ecc0621896cc7c966320800e08.jpg)  
+Figure 14: Results with Block-Pixels on celebA. Rows from top to bottom have blocking probability 0.5, 0.8, 0.9, and 0.98 respectively. The left column shows samples of lossy measurements. The right column shows samples produced by our model.
+
+![](images/3e6bf86af14d4d2e9b35a26e048363cd88fce4af2dd6af479c4dc788b8331634.jpg)  
+Figure 15: Results with Block-Pixels on CIFAR-10. Rows from top to bottom have blocking probability 0.1, 0.5, 0.9, and 0.95 respectively. Columns from left to right are: (1) Samples of lossy measurements. (2) Samples produced by unmeasure-blur baseline. (3) Samples produced by our model.
+
+![](images/b81a0314ccd3cda163b7a016813a2544750f870c2e9b1414b33b4095d046b219.jpg)  
+Figure 16: MNIST with WGANGP (left) Robustness experiment with Block-Pixels measurement (right) Compressed sensing using AmbientGAN. Vertical bars indicate $9 5 \%$ confidence intervals.
+
+# 10.6 ROBUSTNESS TO MEASUREMENT MODEL MISMATCH
+
+So far, in our analysis and experiments, we assumed that the parametric form of the measurement function and the distribution of those parameters is exactly known. This was then used for simulating the stochastic measurement process. Here, we consider the case where the parameter distribution is only approximately known. In this case, one would like the training process to be robust, i.e. the quality of the learned generator to be close to the case where the parameter distribution is exactly known. Through the following experiment, we empirically demonstrate that the AmbientGAN approach is robust to systematic mismatches in the parameter distribution of the measurement function.
+
+Consider the Block-Pixels measurement model (Section 4). We use the MNIST dataset. Pixels are blocked with probability $p ^ { * } = 0 . 5$ to obtain a dataset of measurements. For several values of blocking probability $p$ for the measurement function applied to the output of the generator, we train AmbientGAN models with this dataset. After training, we compute the inception score of the learned generators and plot it as a function of $p$ in Fig. 16 (left). We note that the plot peaks at $p = p ^ { * } = 0 . 5$ and gradually drops on both sides. This suggests that our method is somewhat robust to parameter distribution mismatch.
+
+# 10.7 COMPRESSED SENSING USING AMBIENTGAN
+
+We provide further evidence that the generator learned through AmbientGAN approach captures the data distribution well. Generative models have been shown to improve sensing over sparsitybased approaches [Bora et al. (2017)]. We attempt to use the GAN learned using our procedure for compressed sensing.
+
+We trained an AmbientGAN with Block-Pixels measurement model (Section 4) on MNIST with $p = 0 . 5$ . Using the learned generator, we followed the rest of the procedure in [Bora et al. (2017)] using their code3. Fig. 16 (right) shows a plot of reconstruction error vs the number of measurements, comparing Lasso with AmbienGAN. Thus, we observe a similar reduction in the number of measurements while using AmbientGAN trained with corrupted samples instead of a regular GAN trained with fully observed samples.

parse/train/Hy7fDog0b/Hy7fDog0b_content_list.json

@@ -0,0 +1,1941 @@
+[
+    {
+        "type": "text",
+        "text": "AMBIENTGAN: GENERATIVE MODELS FROM LOSSY MEASUREMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            821,
+            145
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Eric Price ",
+        "text_level": 1,
+        "bbox": [
+            593,
+            171,
+            665,
+            184
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ashish Bora Department of Computer Science University of Texas at Austin ashish.bora@utexas.edu ",
+        "bbox": [
+            184,
+            170,
+            405,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Department of Computer Science University of Texas at Austin ecprice@cs.utexas.edu ",
+        "bbox": [
+            593,
+            185,
+            813,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Alexandros G. Dimakis   \nDepartment of Electrical and Computer Engineering   \nUniversity of Texas at Austin   \ndimakis@austin.utexas.edu ",
+        "bbox": [
+            184,
+            247,
+            527,
+            303
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            340,
+            544,
+            354
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Generative models provide a way to model structure in complex distributions and have been shown to be useful for many tasks of practical interest. However, current techniques for training generative models require access to fully-observed samples. In many settings, it is expensive or even impossible to obtain fullyobserved samples, but economical to obtain partial, noisy observations. We consider the task of learning an implicit generative model given only lossy measurements of samples from the distribution of interest. We show that the true underlying distribution can be provably recovered even in the presence of per-sample information loss for a class of measurement models. Based on this, we propose a new method of training Generative Adversarial Networks (GANs) which we call AmbientGAN. On three benchmark datasets, and for various measurement models, we demonstrate substantial qualitative and quantitative improvements. Generative models trained with our method can obtain $2 { - } 4 \\mathbf { x }$ higher inception scores than the baselines. ",
+        "bbox": [
+            233,
+            369,
+            764,
+            563
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            587,
+            336,
+            603
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Generative models are powerful tools to concisely represent the structure in large datasets. An implicit generative model is a mechanism that only specifies a stochastic procedure to produce samples from a probability distribution. These models are attractive since they do not require an explicit parametrization of the probability distribution they are trying to model. ",
+        "bbox": [
+            174,
+            617,
+            823,
+            672
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recently, there has been substantial progress in neural-network based implicit generative models within the autoregressive and the adversarial framework. The adversarial framework was pioneered by Generative Adversarial Networks (GANs) [Goodfellow et al. (2014)]. In these models, a generator network attempts to map samples from a simple low-dimensional distribution (such as standard Gaussian) to points in a high-dimensional space that resemble the learned data distribution. At the same time, a discriminator network attempts to distinguish between real and generated samples. By setting up a min-max game between them, the two networks are jointly trained. The latent probability distribution along with the learned generator network define a stochastic procedure that can produce new samples. The adversarial framework has been shown to be extremely successful in modeling complex distributions [Berthelot et al. (2017); Vondrick et al. (2016); Pascual et al. (2017); Wu et al. (2016)], and the priors induced by these models are useful for various applications [Shrivastava et al. (2016); Ho & Ermon (2016)]. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            847
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This procedure for training generative models requires access to a large number of fully-observed samples from the desired distribution. Unfortunately, obtaining multiple high-resolution samples can be expensive or impractical for some applications. For example, many sensing and tomography problems (e.g. MRI, CT Scan) require a large number of projections for good reconstruction. Compressed sensing [Donoho (2006); Candes et al. (2006)] attempts to ameliorate this problem using models of the data structure. Recent work has shown that generative models can be particularly effective for easier sensing [Bora et al. (2017); Mardani et al. (2017)]—but if sensing is expensive in the first place, how can we collect enough data to train a generative model to start with? ",
+        "bbox": [
+            176,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/51c37674a10740991f2bd1a893a307af611ee97edd1cbd4ef98a023425af46cc.jpg",
+        "image_caption": [
+            "Figure 1: AmbientGAN training. The output of the generator is passed through a simulated random measurement function $f _ { \\Theta }$ . The discriminator must decide if a measurement is real or generated. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            338,
+            102,
+            661,
+            262
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            335,
+            825,
+            377
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This work solves this chicken-and-egg problem by training a generative model directly from noisy or incomplete samples. We show that our observations can be even projections or more general measurements of different types and the unknown distribution is still provably recoverable. A critical assumption for our framework and theory to work is that the measurement process is known and satisfies certain technical conditions. ",
+        "bbox": [
+            174,
+            385,
+            823,
+            454
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We present several measurement processes for which it is possible to learn a generative model from a dataset of measured samples, both in theory and in practice. Our approach uses a new way of training GANs, which we call AmbientGAN. The idea is simple: rather than distinguish a real image from a generated image as in a traditional GAN, our discriminator must distinguish a real measurement from a simulated measurement of a generated image; see Figure 1. We empirically demonstrate the effectiveness of our approach on three datasets and a variety of measurement models. Our method is able to construct good generative models from extremely noisy observations and even from low dimensional projections with drastic per-sample information loss. We show this qualitatively by exhibiting samples with good visual quality, and quantitatively by comparing inception scores [Salimans et al. (2016)] to baseline methods. ",
+        "bbox": [
+            174,
+            462,
+            825,
+            601
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Theoretical results. We first consider measurements that are noisy, blurred versions of the desired images. That is, we consider convolving the original image with a Gaussian kernel and adding independent Gaussian noise to each pixel (our actual theorem applies to more general kernels and noise distributions). Because of the noise, this process is not invertible for a single image. However, we show that the distribution of measured images uniquely determines the distribution of original images. This implies that a pure Nash equilibrium for the GAN game must find a generative model that matches the true distribution. We show similar results for a dropout measurement model, where each pixel is set to zero with some probability $p$ , and a random projection measurement model, where we observe the inner product of the image with a random Gaussian vector. ",
+        "bbox": [
+            174,
+            622,
+            825,
+            747
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Empirical results. Our empirical work also considers measurement models for which we do not have provable guarantees. We present results on some of our models now and defer the full exploration to Section 8. ",
+        "bbox": [
+            174,
+            770,
+            823,
+            810
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 2, we consider the celebA dataset of celebrity faces [Liu et al. (2015)] under randomly placed occlusions, where a randomly placed square containing $1 / 4$ of the pixels is set to zero. It is hard to inpaint individual images, so cleaning up the data by inpainting and then learning a GAN on the result yields significant artifacts. By incorporating the measurement process into the GAN training, we can produce much better samples. ",
+        "bbox": [
+            174,
+            818,
+            823,
+            888
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 3a we consider learning from noisy, blurred version of images from the celebA dataset. Each image is convolved with a Gaussian kernel and then IID Gaussian noise is added to each pixel. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            922
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/a13d65e89fbc9b3770a321646a003f0ee39f8a9dfe231b0f478d90600a07e3e7.jpg",
+        "image_caption": [
+            "Figure 2: (Left) Samples of lossy measurements used for training. Samples produced by (middle) a baseline that trains from inpainted images, and (right) our model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            101,
+            815,
+            262
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "(a) (left) Samples of lossy measurements. Each image is a blurred noisy version of the original. Samples produced by (middle) a baseline that uses Wiener deconvolution, and (right) our model. ",
+        "bbox": [
+            178,
+            472,
+            475,
+            522
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/bf0c968b12a9a7bfd6dfcfe3afdcfe3d8cea340b86963bc151d3f4620b633895.jpg",
+        "image_caption": [
+            "Figure 3: Results with Convolve $^ +$ Noise on celebA (left) and 1D-projections on MNIST (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            318,
+            470,
+            465
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/b28986aaea93b814a4485df540f63b399c089ce755ed9826135a197286bd7b17.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            496,
+            325,
+            810,
+            445
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "(b) Samples produced by our model trained from two 1D projections of each image. On left, the training data does not include the angle of the projections, so it cannot identify orientation or chirality. On right, the training data includes the angle. ",
+        "bbox": [
+            496,
+            452,
+            818,
+            515
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Learning a GAN on images denoised by Wiener deconvolution leads to poor sample quality while our models are able to produce cleaner samples. ",
+        "bbox": [
+            173,
+            577,
+            823,
+            606
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 3b, we consider learning a generative model on the 2D images in the MNIST handwritten digit dataset [LeCun et al. (1998)] from pairs of 1D projections. That is, measurements consist of picking two random lines and projecting the image onto each line, so the observed value along the line is the sum of all pixels that project to that point. We consider two variants: in the first, the choice of line is forgotten, while in the second the measurement includes the choice of line. We find for both variants that AmbientGAN recovers a lot of the underlying structure, although the first variant cannot identify the distribution up to rotation or reflection. ",
+        "bbox": [
+            174,
+            612,
+            825,
+            709
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            731,
+            344,
+            747
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "There are two distinct approaches to constructing neural network based implicit generative models;   \nautoregressive [Kingma & Welling (2013); Oord et al. (2016b;a)], and adversarial [Goodfellow et al.   \n(2014)]. Some combination approaches have also been successful [Mescheder et al. (2017)]. ",
+        "bbox": [
+            174,
+            763,
+            823,
+            805
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The adversarial framework has been shown to be extremely powerful in modeling complex data distributions such as images [Radford et al. (2015); Arjovsky et al. (2017); Berthelot et al. (2017)], video [Liang et al. (2017); Vondrick et al. (2016)], and 3D models [Achlioptas et al. (2017); Wu et al. (2016)]. A learned generative model can be useful for many applications. A string of papers [Bora et al. (2017); Zhu et al. (2016); Yeh et al. (2016)] explore the utility of generative priors to solve ill-posed inverse problems. [Shrivastava et al. (2016)] demonstrate that synthetic data can be made more realistic using GANs. [Isola et al. (2016)] and [Zhu et al. (2017)] show how to translate images from one domain to another using GANs. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The idea of operating generators and discriminators on different spaces has been proposed before. [Neyshabur et al. (2017)] explores an interesting connection of training stability with low dimensional projections of samples. They show that training a generator against an array of discriminators, each operating on a different low-dimensional projection of the data can improve stability. Our work is also closely related to [Gadelha et al. (2016)] where the authors create 3D object shapes from a dataset of 2D projections. We note that their setup is a special case of the AmbientGAN framework where the measurement process creates 2D projections using weighted sums of voxel occupancies. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 NOTATION AND OUR APPROACH",
+        "text_level": 1,
+        "bbox": [
+            176,
+            223,
+            470,
+            238
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Throughout, we use superscript $\\cdot _ { r } ,$ to denote real or true distribution, superscript $\\dot { \\boldsymbol g }$ ’ for the generated distributions, $\\cdot _ { x } { \\mathrm { : } }$ ’ for the underlying space and $\\cdot _ { y } ,$ for measurements. Let $p _ { x } ^ { r }$ be a real underlying distribution over $\\mathbb { R } ^ { n }$ . We observe lossy measurements performed on samples from $p _ { x } ^ { r }$ . If we let $m$ be the size of each observed measurement, then, each measurement is an output of some measurement function $f _ { \\theta } : \\mathbb { R } ^ { n }  \\mathbb { R } ^ { m }$ , parameterized by $\\theta$ . We allow the measurement function to be stochastic by letting the parameters of the measurement functions have a distribution $p _ { \\theta }$ . With this notation, for a given $x$ and $\\theta$ , the measurements are given by $y = f _ { \\boldsymbol { \\theta } } ( \\boldsymbol { x } )$ . We assume that it is easy to sample $\\Theta \\sim p _ { \\theta }$ and to compute $f _ { \\boldsymbol { \\theta } } ( \\boldsymbol { x } )$ for any $x$ and $\\theta$ . The distributions $p _ { x } ^ { r }$ and $p _ { \\theta }$ naturally induce a distribution over the measurements $y$ which we shall denote by $p _ { y } ^ { r }$ . In other words, if $X \\sim p _ { x } ^ { r }$ and $\\Theta \\sim p _ { \\theta }$ , then $Y = f _ { \\Theta } ( X ) \\sim p _ { y } ^ { r }$ . ",
+        "bbox": [
+            173,
+            255,
+            825,
+            398
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our task is the following: there is some unknown distribution $p _ { x } ^ { r }$ and a known distribution $p _ { \\theta }$ . We are given a set of IID realizations $\\{ y _ { 1 } , y _ { 2 } , \\dots , y _ { s } \\}$ from the distribution $p _ { y } ^ { r }$ . Using these, our goal is to create an implicit generative model of $p _ { x } ^ { r }$ , i.e., a stochastic procedure that can sample from $p _ { x } ^ { r }$ . ",
+        "bbox": [
+            176,
+            402,
+            823,
+            445
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our main idea is to combine the measurement process with the adversarial training framework, as shown in Fig. 1. Just like in the standard GAN setting, let $Z \\in \\mathbb { R } ^ { k } , Z \\sim p _ { z }$ be a random latent vector for a distribution $p _ { z }$ that is easy to sample from, such as IID Gaussian or IID uniform. Let $G : \\mathbb { R } ^ { k }  \\mathbb { R } ^ { n }$ be a generator. Let $X ^ { g } = G ( Z )$ , and let $p _ { x } ^ { g }$ be the distribution of $X ^ { g }$ . Thus, our goal is to learn a generator $G$ such that $p _ { x } ^ { g }$ is close to $p _ { x } ^ { r }$ . ",
+        "bbox": [
+            173,
+            452,
+            825,
+            523
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "However, unlike the standard GAN setting, we do not have access to the desired objects $( X \\sim p _ { x } ^ { r } )$ . Instead, we only have a dataset of measurements (samples from $Y \\sim p _ { y } ^ { r } )$ . Our main idea is to simulate random measurements on the generated objects $X ^ { g }$ , and use the discriminator to distinguish real measurements from fake measurements. Thus, we sample a random measurement function $f _ { \\Theta }$ by sampling $\\Theta \\sim p _ { \\theta }$ and apply it on $X ^ { g }$ to obtain $Y ^ { g } = \\bar { { f } _ { \\Theta } } ( X ^ { g } ) = f _ { \\Theta } ( { G } ( Z ) )$ . Let $p _ { y } ^ { g }$ be the distribution of $Y ^ { g }$ . We set up the discriminator to predict if a given $y$ is a sample from the real measurement distribution $p _ { u } ^ { r }$ as opposed to the generated measurement distribution $p _ { y } ^ { g }$ . Thus, the discriminator is a function $\\dot { D } : \\mathbb { R } ^ { \\dot { m } }  \\mathbb { R }$ . ",
+        "bbox": [
+            173,
+            529,
+            825,
+            640
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We let $q ( \\cdot )$ be the quality function that is used to define the objective, based on the discriminator output. For vanilla GAN, $q ( x ) = \\log ( x )$ and for Wasserstein GAN [Arjovsky et al. (2017)], $q ( x ) =$ $x$ . Accordingly, the AmbientGAN objective is the following: ",
+        "bbox": [
+            174,
+            647,
+            825,
+            689
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/62b9839fbf2251848f9cd6f14bbe0c62a952784aeb610d7b4af64bd394cf6c92.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { G } \\operatorname* { m a x } _ { D } \\mathbb { E } _ { Y ^ { r } \\sim p _ { y } ^ { r } } [ q ( D ( Y ^ { r } ) ) ] + \\mathbb { E } _ { Z \\sim p _ { z } , \\Theta \\sim p _ { \\theta } } [ q ( 1 - D ( f _ { \\Theta } ( G ( Z ) ) ) ) ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            269,
+            696,
+            725,
+            720
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We additionally require $f _ { \\theta }$ to be differentiable with respect to its inputs for all $\\theta$ . We implement $G$ and $D$ as feedforward neural networks. With these assumptions, our model is end-to-end differentiable and can be trained using an approach similar to the standard gradient-based GAN training procedure. In each iteration, we sample $Z \\sim p _ { z }$ , $\\Theta \\sim p _ { \\theta }$ , and $Y ^ { r } \\sim \\mathrm { U N I F } \\{ y _ { 1 } , y _ { 2 } , . . . , y _ { s } \\}$ to use them to compute stochastic gradients of the objective with respect to parameters in $G$ and $D$ by backpropagation. We alternate between updates to parameters of $D$ and updates to parameters of $G$ . ",
+        "bbox": [
+            174,
+            734,
+            825,
+            820
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We note that our approach is compatible with and complementary to the various improvements proposed to the GAN objective, network architectures, and the training procedures. Additionally, we can easily incorporate additional information, such as per sample labels, in our framework through conditional versions of the generator and discriminator. This is exemplified in our experiments, where we use unconditional and conditional versions of DCGAN [Radford et al. (2015)], unconditional Wasserstein GAN with gradient penalty [Gulrajani et al. (2017)], and an Auxiliary Classifier Wasserstein GAN [Odena et al. (2016)] with gradient penalty. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 MEASUREMENT MODELS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            416,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Now, we describe the measurement models that we use for our theoretical and empirical results. We primarily focus on 2D images and thus our measurement models are tailored to this setting. The AmbientGAN learning framework, however, is more general and can be used for other data formats and other measurement models as well. For the rest of this section, we assume that input to the measurement function $( x )$ is a 2D image. We consider the following measurement models: ",
+        "bbox": [
+            174,
+            135,
+            825,
+            205
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Block-Pixels: Each pixel is independently set to zero with probability $p$ . Convolve+Noise: Let $k$ be a convolution kernel and let $\\Theta \\sim p _ { \\theta }$ be the distribution of noise. Then the measurements are given by $f _ { \\Theta } ( x ) = k * x + \\Theta$ , where $^ *$ is the convolution operator. Block-Patch: A randomly chosen $k \\times k$ patch is set to zero. Keep-Patch: All pixels outside a randomly chosen $k \\times k$ patch are set to zero. Extract-Patch: A random $k \\times k$ patch is extracted. Note that unlike the previous measurement function, the information about the location of the patch is lost. Pad-Rotate-Project: We pad the image on all four sides by zeros. Then we rotate the image by a random angle $\\mathbf { \\eta } ^ { ( \\theta ) }$ about its center. The padding is done to make sure that the original pixels stay within the boundary. Finally, for each channel in the image, we sum the pixels along the vertical axis to get one measurement vector. PadRotate-Project- $\\theta$ : This is the same as the previous measurement function, except that along with the projection values, the chosen angle is also included in the measurements. Gaussian-Projection: We project onto a random Gaussian vector which is included in the measurements. So, $\\Theta \\sim \\mathcal { N } ( 0 , I _ { n } )$ , and $f _ { \\Theta } ( x ) = ( \\Theta , \\langle \\Theta , x \\rangle )$ . ",
+        "bbox": [
+            173,
+            212,
+            826,
+            393
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 THEORETICAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            416,
+            406,
+            433
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We show that we can provably recover the true underlying distribution $p _ { x } ^ { r }$ for certain measurement models. Our broad approach is to show that there is a unique distribution $p _ { x } ^ { r }$ consistent with the observed measurement distribution $p _ { y } ^ { r }$ , i.e., the mapping of distributions of samples $p _ { x } ^ { r }$ to distribution of measurements $p _ { y } ^ { r }$ is invertible even though the map from an individual image $x$ to its measurements $f _ { \\boldsymbol { \\theta } } ( \\boldsymbol { x } )$ is not. If this holds, then the following lemma immediately gives a consistency guarantee with the AmbientGAN training procedure. ",
+        "bbox": [
+            173,
+            449,
+            825,
+            535
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Lemma 5.1. As in Section 3, let $p _ { x } ^ { r }$ be the data distribution, $p _ { \\theta }$ be the distribution over parameters of the measurement functions and $p _ { y } ^ { r }$ be the induced measurement distribution. Further, assume that for the given $p _ { \\theta }$ , there is a unique probability distribution $p _ { x } ^ { r }$ that induces the given measurement distribution $p _ { y } ^ { r }$ . Then, for the vanilla GAN model [Goodfellow et al. (2014)], if the Discriminator $D$ is optimal, so that $\\begin{array} { r } { D ( \\cdot ) = \\frac { p _ { y } ^ { r } ( \\cdot ) } { p _ { y } ^ { r } ( \\cdot ) + p _ { y } ^ { g } ( \\cdot ) } } \\end{array}$ , then a generator $G$ is optimal iff $p _ { x } ^ { g } = p _ { x } ^ { r }$ . ",
+        "bbox": [
+            173,
+            546,
+            825,
+            630
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "All proofs including this one are deferred to Appendix A. Note that the previous lemma makes a non-trivial assumption of uniqueness of the true underlying distribution given the measurement distribution. The next few theorems show that this assumption is satisfied under Gaussian-Projection, Convolve $^ +$ Noise and Block-Pixels measurement models, thus showing that that we can recover the true underlying distribution with the AmbientGAN framework. ",
+        "bbox": [
+            174,
+            647,
+            825,
+            717
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Theorem 5.2. For the Gaussian-Projection measurement model (Section 4), there is a unique underlying distribution $p _ { x } ^ { r }$ that can induce the observed measurement distribution $p _ { y } ^ { r }$ . ",
+        "bbox": [
+            171,
+            728,
+            823,
+            757
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Theorem 5.3. Let $\\mathcal F ( \\cdot )$ denote the Fourier transform and let $\\operatorname { s u p p } ( \\cdot )$ be the support of a function. Consider the Convolve $^ +$ Noise measurement model (Section 4) with the convolution kernel $k$ and additive noise distribution $p _ { \\theta }$ . If $\\operatorname { s u p p } ( \\mathcal { F } ( k ) ) ^ { c } = \\phi$ and $\\operatorname { s u p p } ( \\mathcal { F } ( p _ { \\theta } ) ) ^ { c } = \\phi$ , then there is a unique distribution $p _ { x } ^ { r }$ that can induce the measurement distribution $p _ { y } ^ { r }$ . ",
+        "bbox": [
+            174,
+            770,
+            825,
+            828
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We remark that the required conditions in the preceding theorem are easily satisfied for the common setting of Gaussian blurring kernel with additive Gaussian noise. The same guarantee can be generalized for any continuous and invertible function instead of a convolution. We omit the details. ",
+        "bbox": [
+            174,
+            847,
+            825,
+            888
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our next theorem makes an assumption of a finite discrete set of pixel values. This assumption holds in most practical scenarios since images are represented with a finite number of discrete values per channel. In this setting, in addition to a consistency guarantee, we also give a sample complexity result for approximately learning the distributions in the AmbientGAN framework. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theorem 5.4. Assume that each image pixel takes values in a finite set P. Thus $x \\in P ^ { n } \\subset \\mathbb { R } ^ { n }$ . Assume $0 \\in P$ , and consider the Block-Pixels measurement model (Section 4) with $p$ being the probability of blocking a pixel. If $p < 1$ , then there is a unique distribution $p _ { x } ^ { r }$ that can induce the measurement distribution $p _ { y } ^ { r }$ . Further, for any $\\epsilon > 0$ , $\\delta \\in ( 0 , 1 ]$ , given a dataset of ",
+        "bbox": [
+            173,
+            143,
+            825,
+            200
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4b0919d453f9b40f0e7288b08d2625e343446fdec31acf38fc9c3633a9a835f4.jpg",
+        "text": "$$\ns = \\Omega \\left( \\frac { | P | ^ { 2 n } } { \\left( 1 - p \\right) ^ { 2 n } \\epsilon ^ { 2 } } \\log { \\left( \\frac { | P | ^ { n } } { \\delta } \\right) } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            205,
+            619,
+            248
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "IID measurement samples from $p _ { y } ^ { r }$ , if the discriminator $D$ is optimal, then with probability $\\geq 1 - \\delta$ over the dataset, any optimal generator $G$ must satisfy $d _ { T V } ( p _ { x } ^ { g } , p _ { x } ^ { r } ) \\leq \\epsilon$ , where $d _ { T V } ( \\cdot , \\cdot )$ is the total variation distance. ",
+        "bbox": [
+            174,
+            251,
+            825,
+            295
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6 DATASETS AND MODEL ARCHITECTURES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            316,
+            550,
+            333
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We used three datasets for our experiments. MNIST is a dataset of $2 8 \\times 2 8$ images of handwritten digits [LeCun et al. (1998)]. CelebA is a dataset of face images of celebrities [Liu et al. (2015)]. We use an aligned and cropped version where each image is $6 4 \\times 6 4$ RGB. The CIFAR-10 dataset consists of $3 2 \\times 3 2$ RGB images from 10 different classes [Krizhevsky & Hinton (2009)]. ",
+        "bbox": [
+            174,
+            347,
+            825,
+            404
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We briefly describe the generative models we used for our experiments. More details on architectures and hyperparameters can be found in the appendix. For the MNIST dataset, we use two GAN models. The first model is a conditional DCGAN which follows the architecture in [Radford et al. $( 2 0 1 5 ) ] ^ { 1 }$ , while the second model is an unconditional Wasserstein GAN with gradient penalty (WGANGP) which follows the architecture in [Gulrajani et al. $( 2 0 1 7 ) ] ^ { 2 }$ . For the celebA dataset, we use an unconditional DCGAN and follow the architecture in [Radford et al. $( 2 0 1 5 ) ] ^ { 3 }$ . For the CIFAR-10 dataset, we use an Auxiliary Classifier Wasserstein GAN with gradient penalty (ACWGANGP) which follows the residual architecture in [Gulrajani et al. $( 2 0 1 7 ) ] ^ { 4 }$ . ",
+        "bbox": [
+            174,
+            410,
+            825,
+            522
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For measurements with 2D outputs, i.e. Block-Pixels, Block-Patch, Keep-Patch, Extract-Patch, and Convolve $+$ Noise (see Section 4), we use the same discriminator architectures as in the original work. For 1D projections, i.e. Pad-Rotate-Project, Pad-Rotate-Project- $\\theta$ , we use fully connected discriminators. The architecture of the fully connected discriminator used for the MNIST dataset was 25-25-1 and for the celebA dataset was 100-100-1. ",
+        "bbox": [
+            174,
+            529,
+            825,
+            598
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "7 BASELINES",
+        "text_level": 1,
+        "bbox": [
+            176,
+            618,
+            300,
+            635
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Now, we describe some baseline approaches that we implemented to evaluate the relative performance of the AmbientGAN framework. Recall that we have a dataset of IID samples $\\{ y _ { 1 } , y _ { 2 } , . . . . y _ { s } \\}$ from the measurement distribution $p _ { y } ^ { r }$ and our goal is to create an implicit generative model for $p _ { x } ^ { r }$ . ",
+        "bbox": [
+            174,
+            650,
+            825,
+            693
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A crude baseline is to ignore that any measurement happened at all. In other words, for cases where the measurements lie in the same space as the full-samples (for example Convolve+Noise) we can learn a generative model directly on the measurements and test how well it approximates the true distribution $p _ { x } ^ { r }$ . We call this the “ignore” baseline. ",
+        "bbox": [
+            174,
+            699,
+            825,
+            755
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A stronger baseline is based on the following observation: If the measurement functions $f _ { \\theta }$ were invertible, and we observed $\\theta _ { i }$ for each measurement $y _ { i }$ in our dataset, we could just invert the functions to obtain full-samples $x _ { i } = f _ { \\theta _ { i } } ^ { - 1 } ( y _ { i } )$ . Then we could directly learn a generative model using these full-samples. Notice that both assumptions are violated in the AmbientGAN setting. First, we may not observe $\\theta _ { i }$ and second, the functions may not be invertible. Indeed all the measurement models in Section 4 violate one of the assumptions. However, we can try to approximate an inverse function and use the inverted samples to train a generative model. Thus, given a measurement $y _ { i } = f _ { \\boldsymbol { \\theta } _ { i } } ( x _ { i } )$ , we try to “unmeasure” it and obtain $\\widehat { x } _ { i }$ , an estimate of $x _ { i }$ . We then learn a generative bmodel with the estimated inverse samples and test how well it approximates $p _ { x } ^ { r }$ . ",
+        "bbox": [
+            174,
+            762,
+            825,
+            887
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/d20502dc83ca7926d16b6fd2c4cd621065c145c49dd096f2d9b7a0a37eb0e91f.jpg",
+        "image_caption": [
+            "Figure 4: Results with Block-Pixels on celebA. (left) Samples of lossy measurements. Each pixel is blocked independently with probability $p = 0 . 9 5$ . Samples produced by (middle) unmeasure-blur baseline, and (right) our model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            101,
+            807,
+            199
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/e3ace6a56e04f1d401067ba2ef70d66148c3475e4418e1d20de22f705a45806d.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            275,
+            584,
+            372
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "(a) (left) Samples of lossy measurements. All except a randomly chosen $3 2 \\times 3 2$ patch is set to zero. (right) Samples produced by our model. ",
+        "bbox": [
+            173,
+            378,
+            589,
+            404
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/1bd8881fd1f6cb91d938ab6218e2a96f539aa0b7b50def00641abf7ce5d3e3fa.jpg",
+        "image_caption": [
+            "(b) Samples produced by our model with Pad-Rotate-Project- $\\theta$ measurements. ",
+            "Figure 5: Results on celebA with (a) Keep-Patch, and (b) 1D projections. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            612,
+            270,
+            820,
+            367
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For the measurement models described in Section 4, we now describe the methods we used to obtain approximate inverse functions: (a) For the Block-Pixels measurements, a simple approximate inverse function is to just blur the image so that zero pixels are filled in from the surrounding. We also implemented a more sophisticated approach to fill in the pixels by using total variation inpainting. (b) For Convolve+Noise measurements with a Gaussian kernel and additive Gaussian Noise, we approximate the inverse by a Wiener deconvolution. (c) For Block-Patch measurements, we use the Navier Stokes based inpainting method [Bertalmio et al. (2001)] to fill in the zero pixels. ",
+        "bbox": [
+            174,
+            468,
+            825,
+            565
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For other measurement models, it is unclear how to obtain an approximate inverse function. For the Keep-Patch measurement model, no pixels outside a box are known and thus inpainting methods are not suitable. Inverting Extract-Patch measurements is even harder since the information about the position of the patch is also lost. For the Pad-Rotate-Project- $\\theta$ measurements, a conventional technique is to sample many angles, and use techniques for inverting the Radon transform [Deans (2007)]. However, since we observe only a few projections at a time, these methods aren’t readily applicable. Inverting Pad-Rotate-Project measurements is even harder since it lacks information about $\\theta$ . So, on this subset of experiments, we report only the results with the AmbientGAN models. ",
+        "bbox": [
+            174,
+            571,
+            825,
+            684
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "8 QUALITATIVE RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            708,
+            401,
+            724
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We present some samples generated by the baselines and our models. For each experiment, we show the samples from the dataset of measurements $( Y ^ { r } )$ available for training, samples generated by the baselines (when applicable) and the samples generated by our models $( X ^ { g } )$ . We show samples only for a selected value of parameter settings. More results are provided in the appendix. All results on MNIST are deferred to the appendix. ",
+        "bbox": [
+            174,
+            742,
+            823,
+            811
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Block-Pixels: Fig. 4 shows results on celebA with DCGAN and Fig. 6 on CIFAR-10 with ACWGANGP. We see that the samples are heavily degraded in our measurement process (left image). Thus, it is challenging for baselines to invert the measurements process, and correspondingly, they do not produce good samples (middle image). Our models are able to produce images with good visual quality (right image). ",
+        "bbox": [
+            174,
+            818,
+            823,
+            888
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Convolve+Noise: We use a Gaussian kernel and IID Gaussian noise. Fig. 3a shows results on celebA with DCGAN. We see that the measurements are drowned in noise (left image) and the baselines struggle to extract the original image, giving samples of low quality (middle image). Our models are able to produce samples with clear faces (right image). ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/75361c5173e18fbc98f3334d46b893d75d6d5138f3a7078abba97c4b84f9d858.jpg",
+        "image_caption": [
+            "Figure 6: Results with Block-Pixels on CIFAR-10. (left) Samples of lossy measurements. Each pixel is blocked independently with probability $p = 0 . 8$ . Samples produced by (middle) unmeasure-blur baseline, and (right) our model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            101,
+            805,
+            231
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            315,
+            823,
+            343
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Block-Patch, Keep-Patch: Fig. 2 shows the results for Block-Patch and Fig. 5a for Keep-Patch measurements on celebA with DCGAN. On both measurement distributions, our models are able to create coherent faces (right image) by observing only parts of one image at a time. ",
+        "bbox": [
+            174,
+            349,
+            825,
+            392
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "1D projections: Pad-Rotate-Project and Pad-Rotate-Project- $\\theta$ measurement models exhibit drastic signal degradation; most of the information in a sample is lost during the measurements process. For our experiments, we use two measurements at a time. Fig. 3b shows the results on MNIST with DCGAN. While the first model is able to learn only up to rotation and reflection (left image), we note that generated digits have similar orientations and chirality within each class without any explicit incentive. We hypothesize that the model prefers this mode because it is easier to learn with consistent orientation per class. The second measurement model contains the rotation angle and thus produces upright digits (right image). While in both cases, the generated images are of lesser visual quality, our method demonstrates that we can produce images of digits given only 1D projections. ",
+        "bbox": [
+            174,
+            398,
+            825,
+            525
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Failure case: In Fig. 5b, we show the samples obtained from our model trained on celebA dataset with Pad-Rotate-Project- $\\cdot \\theta$ measurements with a DCGAN. We see that the model has learned a very crude outline of a face, but lacks details. This highlights the difficulty in learning complex distributions with just 1D projections and a need for better understanding of distribution recovery under projection measurement model as well as better methods for training GANs. ",
+        "bbox": [
+            174,
+            531,
+            825,
+            601
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "9 QUANTITATIVE RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            626,
+            413,
+            642
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We report inception scores [Salimans et al. (2016)] to quantify the quality of the generative models learned in the AmbientGAN framework. For the CIFAR-10 dataset, we use the Inception model[Szegedy et al. (2016)] trained on the ImageNet dataset [Deng et al. $( 2 0 0 9 ) ] ^ { 1 }$ . For computing a similar score on MNIST, we trained a classification model with two conv+pool layers followed by two fully connected layers2. The final test set accuracy of this model was $9 9 . 2 \\%$ . ",
+        "bbox": [
+            174,
+            660,
+            825,
+            731
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "9.1 MNIST ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            752,
+            269,
+            766
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For Block-Pixels measurements on MNIST, we trained several models with our approach and the baselines, each with a different probability $p$ of blocking pixels. For each model, after convergence, we computed the inception score using the network described above. A plot of the inception scores as a function of $p$ is shown in Fig. 7 (left). We note that at $p = 0$ , i.e. if no pixels are blocked, our model is equivalent to a conventional GAN. As we increase $p$ , the baseline models quickly start to perform poorly, while the AmbientGAN models continue to perform relatively well. ",
+        "bbox": [
+            174,
+            780,
+            825,
+            864
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/d01f15ed3eae1a255775fecb3efc931f67658bcfc06365b5f8467be528ac4be7.jpg",
+        "image_caption": [
+            "Figure 7: Results on MNIST with WGANGP. (left) Block-Pixels (right) Convolve+Noise "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            104,
+            807,
+            270
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/caf6bd49ebfdbecfdf4b4bc12e688f2fa0758753cfa2dc0c209d6de8a6134b23.jpg",
+        "image_caption": [
+            "Figure 8: Quantitative results on CIFAR-10 with ACWGANGP, Block-Pixels measurement. (left) Inception score vs blocking probability $p$ . (right) Inception score vs training iteration with darkness proportional to $1 - p$ . Vertical bars indicate $9 5 \\%$ confidence intervals. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            328,
+            803,
+            492
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "For the Convolve+Noise measurements with a Gaussian kernel of radius 1 pixel, and additive Gaussian noise with zero mean and standard deviation $\\sigma$ , we trained several models on MNIST by varying the value of $\\sigma$ . A plot of the inception score as a function of $\\sigma$ is shown in Fig. 7 (right). We see that for small variance of additive noise, Wiener deconvolution and the “ignore” baseline perform quite well. However, as we start to increase the noise levels, these baselines quickly deteriorate in performance, while the AmbientGAN models maintain a high inception score. ",
+        "bbox": [
+            174,
+            588,
+            825,
+            671
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "For 1D projection measurements, we report the inception scores for the samples produced by the AmbientGAN models trained with two projection measurements at a time. The Pad-Rotate-Project model produces digits at various orientations and thus does quite poorly, achieving an inception score of just 4.18. The model with Pad-Rotate-Project- $\\cdot \\theta$ measurements produces well-aligned digits and achieves an inception score of 8.12. For comparison, the vanilla GAN model trained with fullyobserved samples achieves an inception score of 8.99. Thus, the second model comes quite close to the performance of the fully-observed case while being trained only on 1D projections. ",
+        "bbox": [
+            174,
+            679,
+            825,
+            776
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "9.2 CIFAR-10 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            808,
+            289,
+            821
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 8 (left), we show a plot of inception score vs the probability of blocking pixels $p$ in the BlockPixels measurement model on CIFAR-10. We note that the total variation inpainting method is quite slow and the performance on MNIST was about the same as unmeasure-blur baseline. So, we do not run inpainting baselines on the CIFAR-10 dataset. From the plots, we see a trend similar to the plot obtained with MNIST (Fig. 7, left), showing the superiority of our approach over baselines. We show the inception score as a function of training iteration in Fig. 8 (right). ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "10 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            330,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Generative models are powerful tools, but constructing a generative model requires a large, highquality dataset of the distribution of interest. We show how to relax this requirement, by learning a distribution from a dataset that only contains incomplete, noisy measurements of the distribution. We hope that this will allow for the construction of new generative models of distributions for which no high-quality dataset exists. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            204
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            227,
+            367,
+            241
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We would like to thank Philipp Krahenb ¨ uhl, Ajil Jalal, Surbhi Goel, and Jessica Hoffmann for ¨ helpful discussions. This research has been supported by NSF Grants CCF 1407278, 1422549, 1618689, DMS 1723052, ARO YIP W911NF-14-1-0258 and NVIDIA Corporation. ",
+        "bbox": [
+            174,
+            257,
+            825,
+            299
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            321,
+            285,
+            335
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Panos Achlioptas, Olga Diamanti, Ioannis Mitliagkas, and Leonidas Guibas. Representation learning and adversarial generation of 3d point clouds. arXiv preprint arXiv:1707.02392, 2017.   \nMartin Arjovsky, Soumith Chintala, and Leon Bottou. Wasserstein gan. ´ arXiv preprint arXiv:1701.07875, 2017.   \nMarcelo Bertalmio, Andrea L Bertozzi, and Guillermo Sapiro. Navier-stokes, fluid dynamics, and image and video inpainting. In Computer Vision and Pattern Recognition, 2001. CVPR 2001. Proceedings of the 2001 IEEE Computer Society Conference on, volume 1, pp. I–I. IEEE, 2001.   \nDavid Berthelot, Tom Schumm, and Luke Metz. Began: Boundary equilibrium generative adversarial networks. arXiv preprint arXiv:1703.10717, 2017.   \nAshish Bora, Ajil Jalal, Eric Price, and Alexandros G Dimakis. Compressed sensing using generative models. arXiv preprint arXiv:1703.03208, 2017.   \nEmmanuel J Candes, Justin K Romberg, and Terence Tao. Stable signal recovery from incomplete and inaccurate measurements. Communications on pure and applied mathematics, 59(8):1207– 1223, 2006.   \nHarald Cramer and Herman Wold. Some theorems on distribution functions. ´ Journal of the London Mathematical Society, 1(4):290–294, 1936.   \nStanley R Deans. The Radon transform and some of its applications. Courier Corporation, 2007.   \nJia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In Computer Vision and Pattern Recognition, 2009. CVPR 2009. IEEE Conference on, pp. 248–255. IEEE, 2009.   \nDavid L Donoho. Compressed sensing. IEEE Transactions on information theory, 52(4):1289– 1306, 2006.   \nMatheus Gadelha, Subhransu Maji, and Rui Wang. 3d shape induction from 2d views of multiple objects. arXiv preprint arXiv:1612.05872, 2016.   \nIan Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pp. 2672–2680, 2014.   \nIshaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron Courville. Improved training of wasserstein gans. arXiv preprint arXiv:1704.00028, 2017.   \nJonathan Ho and Stefano Ermon. Generative adversarial imitation learning. In Advances in Neural Information Processing Systems, pp. 4565–4573, 2016.   \nPhillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A Efros. Image-to-image translation with conditional adversarial networks. arXiv preprint arXiv:1611.07004, 2016.   \nDiederik $\\mathrm { \\bf P }$ Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013.   \nAlex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.   \nYann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.   \nXiaodan Liang, Lisa Lee, Wei Dai, and Eric P Xing. Dual motion gan for future-flow embedded video prediction. arXiv preprint arXiv:1708.00284, 2017.   \nZiwei Liu, Ping Luo, Xiaogang Wang, and Xiaoou Tang. Deep learning face attributes in the wild. In Proceedings of the IEEE International Conference on Computer Vision, pp. 3730–3738, 2015.   \nMorteza Mardani, Enhao Gong, Joseph Y Cheng, Shreyas Vasanawala, Greg Zaharchuk, Marcus Alley, Neil Thakur, Song Han, William Dally, John M Pauly, et al. Deep generative adversarial networks for compressed sensing automates mri. arXiv preprint arXiv:1706.00051, 2017.   \nLars Mescheder, Sebastian Nowozin, and Andreas Geiger. Adversarial variational bayes: Unifying variational autoencoders and generative adversarial networks. arXiv preprint arXiv:1701.04722, 2017.   \nBehnam Neyshabur, Srinadh Bhojanapalli, and Ayan Chakrabarti. Stabilizing gan training with multiple random projections. arXiv preprint arXiv:1705.07831, 2017.   \nAugustus Odena, Christopher Olah, and Jonathon Shlens. Conditional image synthesis with auxiliary classifier gans. arXiv preprint arXiv:1610.09585, 2016.   \nAaron van den Oord, Sander Dieleman, Heiga Zen, Karen Simonyan, Oriol Vinyals, Alex Graves, Nal Kalchbrenner, Andrew Senior, and Koray Kavukcuoglu. Wavenet: A generative model for raw audio. arXiv preprint arXiv:1609.03499, 2016a.   \nAaron van den Oord, Nal Kalchbrenner, and Koray Kavukcuoglu. Pixel recurrent neural networks. arXiv preprint arXiv:1601.06759, 2016b.   \nSantiago Pascual, Antonio Bonafonte, and Joan Serra. Segan: Speech enhancement generative \\` adversarial network. arXiv preprint arXiv:1703.09452, 2017.   \nAlec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. arXiv preprint arXiv:1511.06434, 2015.   \nTim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. In Advances in Neural Information Processing Systems, pp. 2234–2242, 2016.   \nAshish Shrivastava, Tomas Pfister, Oncel Tuzel, Josh Susskind, Wenda Wang, and Russ Webb. Learning from simulated and unsupervised images through adversarial training. arXiv preprint arXiv:1612.07828, 2016.   \nChristian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2818–2826, 2016.   \nCarl Vondrick, Hamed Pirsiavash, and Antonio Torralba. Generating videos with scene dynamics. In Advances In Neural Information Processing Systems, pp. 613–621, 2016.   \nJiajun Wu, Chengkai Zhang, Tianfan Xue, Bill Freeman, and Josh Tenenbaum. Learning a probabilistic latent space of object shapes via 3d generative-adversarial modeling. In Advances in Neural Information Processing Systems, pp. 82–90, 2016.   \nRaymond Yeh, Chen Chen, Teck Yian Lim, Mark Hasegawa-Johnson, and Minh N Do. Semantic image inpainting with perceptual and contextual losses. arXiv preprint arXiv:1607.07539, 2016. ",
+        "bbox": [
+            169,
+            340,
+            826,
+            926
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            63,
+            828,
+            930
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jun-Yan Zhu, Philipp Krahenb ¨ uhl, Eli Shechtman, and Alexei A Efros. Generative visual manipu- ¨ lation on the natural image manifold. In European Conference on Computer Vision, pp. 597–613. Springer, 2016. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. arXiv preprint arXiv:1703.10593, 2017. ",
+        "bbox": [
+            173,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX A ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            282,
+            117
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "10.1 PROOF OF LEMMA 5.1 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            133,
+            379,
+            148
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Lemma. As in Section 3, let $p _ { x } ^ { r }$ be the data distribution, $p _ { \\theta }$ be the distribution over parameters of the measurement functions and $p _ { y } ^ { r }$ be the induced measurement distribution. Further, assume that for the given $p _ { \\theta }$ , there is a unique probability distribution $p _ { x } ^ { r }$ that induces the given measurement distribution $p _ { y } ^ { r }$ . Then, for the vanilla GAN model [Goodfellow et al. (2014)], if the Discriminator $D$ is optimal, so that ",
+        "bbox": [
+            173,
+            160,
+            826,
+            231
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/62d0a65029769107f54493af1c6430cda8aa03fdc21a2c6741da7e96685e6407.jpg",
+        "text": "$$\nD ( \\cdot ) = \\frac { p _ { y } ^ { r } ( \\cdot ) } { p _ { y } ^ { r } ( \\cdot ) + p _ { y } ^ { g } ( \\cdot ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            423,
+            231,
+            573,
+            268
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "then a generator $G$ is optimal iff $p _ { x } ^ { g } = p _ { x } ^ { r }$ ",
+        "bbox": [
+            176,
+            272,
+            449,
+            287
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Proof. From the same argument as in Theorem 1 in [Goodfellow et al. (2014)], it follows that $p _ { y } ^ { g } =$ $p _ { y } ^ { r }$ . Then, since there is a unique probability distribution $p _ { x } ^ { r }$ that can induce the given measurement distribution, it follows that $p _ { x } ^ { g } = p _ { x } ^ { r }$ . The converse is trivially true. □ ",
+        "bbox": [
+            174,
+            308,
+            825,
+            351
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "10.2 PROOF OF THEOREM 5.2 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            368,
+            395,
+            382
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Theorem. For the Gaussian-Projection measurement model (Section 4), there is a unique underlying distribution $p _ { x } ^ { r }$ that can induce the observed measurement distribution $p _ { y } ^ { r }$ . ",
+        "bbox": [
+            173,
+            395,
+            821,
+            424
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Proof. We note that Since $\\Theta \\sim \\mathcal { N } ( 0 , I _ { n } )$ , all possible directions for projections are covered. Further, since the measurement model includes the projection vector $\\Theta$ as a part of the measurements, in order to match the measurement distribution, the underlying distribution $p _ { x } ^ { r }$ must be such that all 1D marginals are matched. Thus, by Cramer-Wold theorem [Cramer & Wold (1936)], any sequence ´ of random vectors that match the 1D marginals must converge in distribution to the true underlying distribution. Thus, in particular, there is a unique probability distribution $p _ { x } ^ { r }$ that can match all 1D marginals obtained with the Gaussian projection measurements. □ ",
+        "bbox": [
+            173,
+            444,
+            825,
+            544
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "10.3 PROOF OF THEOREM 5.3 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            561,
+            395,
+            575
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Theorem. Let $\\mathcal F ( \\cdot )$ denote the Fourier transform and let $\\operatorname { s u p p } ( \\cdot )$ be the support of a function. Consider the Convolve+Noise measurement model (Section 4) with the convolution kernel $k$ and additive noise distribution $p _ { \\theta }$ . If $\\operatorname { s u p p } ( \\mathcal { F } ( k ) ) ^ { c } = \\phi$ and $\\operatorname { s u p p } ( \\mathcal { F } ( p _ { \\theta } ) ) ^ { c } = \\phi$ , then there is a unique distribution $p _ { x } ^ { r }$ that can induce the measurement distribution $p _ { y } ^ { r }$ . ",
+        "bbox": [
+            173,
+            588,
+            825,
+            646
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Proof. Let $X \\sim p _ { x }$ . Let $\\Theta \\sim p _ { \\theta }$ . Let $Z = k * X$ so that $Z \\sim p _ { z }$ , and $Y = Z + \\Theta$ , so $Y \\sim p _ { y }$ . With a slight abuse of notation, we will denote the probability density functions (pdf) also by $p$ subscripted with the variable name. Then we have ",
+        "bbox": [
+            174,
+            664,
+            823,
+            707
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d96fe201a3fd6042e3258cd73f6021e7f9e29443d10f8b1e379fdcb8bcf6f44c.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\quad \\quad Z = k * X , } \\\\ & { \\Leftrightarrow \\mathcal { F } ( Z ) = \\mathcal { F } ( k ) \\mathcal { F } ( X ) , } \\\\ & { \\Leftrightarrow \\mathcal { F } ( X ) = \\mathcal { F } ( Z ) / \\mathcal { F } ( k ) , } \\\\ & { \\quad \\quad \\Leftrightarrow X = \\mathcal { F } ^ { - 1 } ( \\mathcal { F } ( Z ) / \\mathcal { F } ( k ) ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            388,
+            714,
+            606,
+            790
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where the penultimate step follows since by assumption, $\\mathcal { F } ( k )$ is nowhere 0. In the last step, ${ \\mathcal { F } } ^ { - 1 }$ is the inverse Fourier transform. ",
+        "bbox": [
+            174,
+            797,
+            823,
+            827
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Thus, there is a bijective map between $X$ and $Z$ . Since the Fourier and the inverse Fourier are continuous transformations, this map is also continuous. So, we can write $Z = h ( X )$ , where $h$ is a bijective, differentiable function. So, the pdfs of $X$ and $Z$ are related as ",
+        "bbox": [
+            174,
+            832,
+            825,
+            876
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a8fa707e601de110cc6d3dffd3f4c0746553dd6f2971fee6f5b42785108b1297.jpg",
+        "text": "$$\np _ { x } ( \\cdot ) = p _ { z } ( h ( \\cdot ) ) \\left| { \\operatorname* { d e t } ( J _ { h } ( \\cdot ) ) } \\right| ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            883,
+            599,
+            901
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where $J _ { h } ( \\widetilde { x } )$ is the Jacobian of $h$ evaluated at $\\tilde { x }$ ",
+        "bbox": [
+            174,
+            909,
+            488,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Now, note that since Y is a sum of two random variables, its pdf is a convolution of the individual probability density functions. So we have: ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/866a1545a097a85875989ceef6fbf6d2dc1920680f9aec16585595e7b6322e1b.jpg",
+        "text": "$$\np _ { y } = p _ { z } * p _ { \\theta }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            454,
+            143,
+            544,
+            159
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Taking the Fourier transform on both sides, we have ",
+        "bbox": [
+            173,
+            172,
+            517,
+            188
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/507ce0682c787b2d3a0a5e3bf99efceedff3a613d0adf7d9a2c650f510eb9a64.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathcal { F } ( { p _ { y } } ) = \\mathcal { F } ( { p _ { z } } ) \\mathcal { F } ( { p _ { \\theta } } ) , } \\\\ & { \\Leftrightarrow \\mathcal { F } ( { p _ { z } } ) = \\mathcal { F } ( { p _ { y } } ) / \\mathcal { F } ( { p _ { \\theta } } ) , } \\\\ & { \\qquad \\Leftrightarrow p _ { z } = \\mathcal { F } ^ { - 1 } ( \\mathcal { F } ( { p _ { y } } ) / \\mathcal { F } ( { p _ { \\theta } } ) ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            195,
+            611,
+            253
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "where the penultimate step follows since by assumption, $\\mathcal { F } ( p _ { \\theta } )$ is nowhere 0. ",
+        "bbox": [
+            174,
+            258,
+            681,
+            275
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Combining the two results, we have a reverse map from the measurement distribution $p _ { y }$ to a sample distribution $p _ { x }$ . Thus, the reverse map uniquely determines the true underlying distribution $p _ { x }$ , concluding the proof. □ ",
+        "bbox": [
+            174,
+            280,
+            825,
+            323
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "10.4 PROOF OF THEOREM 5.4 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            340,
+            395,
+            356
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We first state a slightly different version of Theorem 1 from [Goodfellow et al. (2014)] for the discrete setting. We shall use $[ n ]$ to denote the set $\\{ 1 , 2 , \\ldots n \\}$ , and use $\\mathbb { I } ( \\cdot )$ to denote the indicator function. ",
+        "bbox": [
+            174,
+            367,
+            825,
+            410
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Lemma 10.1. Consider a dataset of measurement samples $\\left\\{ y _ { 1 } , y _ { 2 } , \\dots y _ { s } \\right\\}$ , where each $y _ { i } \\in [ t ]$ . We define the empirical version of the vanilla GAN objective as ",
+        "bbox": [
+            171,
+            421,
+            825,
+            452
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8b45d254a508389e3edb9f376a32288b299eb5969fd17ce46c2d8c0b5a8d2d18.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { G } \\operatorname* { m a x } _ { D } \\frac { 1 } { s } \\sum _ { i = 1 } ^ { s } \\log ( D ( y _ { i } ) ) + \\mathbb { E } _ { Y ^ { g } \\sim p _ { y } ^ { g } } [ \\log ( 1 - D ( Y ^ { g } ) ) ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            469,
+            687,
+            511
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "For $j \\in [ t ]$ , let $\\hat { p } _ { y } ^ { r } ( j ) = \\sum \\mathbb { I } ( y _ { i } = j ) / s$ be the empirical distribution of samples. Then the optimal discriminator for the empirical objective is such that ",
+        "bbox": [
+            173,
+            523,
+            825,
+            551
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2d9bac6052711648cea3bcde00e035dac665bd9ebd164fb855046f77a5a325d8.jpg",
+        "text": "$$\nD ( \\cdot ) = \\frac { \\hat { p } _ { y } ^ { r } ( \\cdot ) } { \\hat { p } _ { y } ^ { r } ( \\cdot ) + p _ { y } ^ { g } ( \\cdot ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            423,
+            559,
+            575,
+            598
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Additionally, if we fix the discriminator to be optimal, then any optimal generator must satisfy $p _ { y } ^ { g } = \\hat { p } _ { y } ^ { r }$ . ",
+        "bbox": [
+            173,
+            611,
+            821,
+            642
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Proof. The Empirical Risk Minimization (ERM) version of the loss is equivalent to the taking expectation of the data dependent term with respect to the empirical distribution. Replacing the real data distribution with the empirical version in the proof of Theorem 1 from [Goodfellow et al. (2014)], we obtain the result. □ ",
+        "bbox": [
+            173,
+            660,
+            825,
+            717
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Now we give a proof of Theorem 5.4. ",
+        "bbox": [
+            174,
+            737,
+            419,
+            752
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Theorem. Assume that each image pixel takes values in a finite set P. Thus $x \\in P ^ { n } \\subset \\mathbb { R } ^ { n }$ . Assume $0 \\in P$ , and consider the Block-Pixels measurement model (Section 4) with $p$ being the probability of blocking a pixel. If $p < 1$ , then there is a unique distribution $p _ { x } ^ { r }$ that can induce the measurement distribution $p _ { y } ^ { r }$ . Further, for any $\\epsilon > 0$ , $\\delta \\in ( 0 , 1 ]$ , given a dataset of ",
+        "bbox": [
+            173,
+            763,
+            825,
+            820
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/616207b7dacd45af5b70f3363761c941636f1be09a9216a49bfe369a0c575757.jpg",
+        "text": "$$\ns = \\Omega \\left( \\frac { | P | ^ { 2 n } } { { ( 1 - p ) } ^ { 2 n } \\epsilon ^ { 2 } } \\log { \\left( \\frac { | P | ^ { n } } { \\delta } \\right) } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            829,
+            619,
+            872
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "IID measurement samples from $p _ { y } ^ { r }$ , if the discriminator $D$ is optimal, then with probability $\\geq 1 - \\delta$ over the dataset, any optimal generator $G$ must satisfy $d _ { T V } ( p _ { x } ^ { g } , p _ { x } ^ { r } ) \\leq \\epsilon$ , where $d _ { T V } ( \\cdot , \\cdot )$ is the total variation distance. ",
+        "bbox": [
+            174,
+            880,
+            825,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Proof. We first consider a more general case and apply that to the Block-Pixels model. Consider a discrete distribution $p _ { x }$ over $[ t ]$ . We apply random measurement functions to samples from $p _ { x }$ to obtain measurements. Assume that each measurement also belongs to the same set, i.e. $[ t ]$ . Let $A \\ \\in \\ \\mathbb { R } ^ { t \\times t }$ be the transition matrix so that $A _ { i j }$ is the probability (under the randomness in measurement functions) that measurement $i$ was produced by sample $j$ . Then the distribution over measurements $p _ { y }$ can be written in terms of $p _ { x }$ and $A$ as: ",
+        "bbox": [
+            173,
+            102,
+            825,
+            188
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a299bc5561077c871700bd622efe3e4597f5e5fddc9dd9d337384010ac15823d.jpg",
+        "text": "$$\np _ { y } = A p _ { x }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            464,
+            194,
+            534,
+            212
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Thus, if the matrix $A$ is invertible, we can guarantee that the distribution $p _ { x }$ is recoverable from $p _ { y }$ ",
+        "bbox": [
+            169,
+            224,
+            821,
+            241
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Assuming $A$ is invertible, we now turn to the sample complexity. Let $\\lambda$ be the minimum of magnitude of eigenvalues of $A$ . Since $A$ is invertible, $\\lambda > 0$ . Let the dataset of measurements be $\\left\\{ y _ { 1 } , y _ { 2 } , \\dots y _ { s } \\right\\}$ . For $j \\in [ t ]$ and for $k \\in [ s ]$ , Let $Y _ { k } ^ { j } = \\mathbb { I } ( y _ { k } = j )$ . Then for any $\\epsilon > 0$ , we have ",
+        "bbox": [
+            174,
+            246,
+            825,
+            292
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/423a4cc5d97a5141e7ce0e4a1680aa5241e2cb88d826c7d5721b314b9636e976.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\mathbb { E } \\left( \\left| | \\hat { \\nu } _ { y } ^ { \\star } - \\bar { p } _ { y } ^ { \\star } | \\right| \\geq \\frac { \\lambda ^ { 2 } \\epsilon ^ { 2 } } { t } \\right) = } & { \\mathbb { E } \\left( \\displaystyle \\sum _ { i = 1 } ^ { t } \\bar { ( \\hat { \\nu } _ { y } ^ { \\star } ( j ) - p _ { i } ^ { \\star } ( j ) ) ^ { 2 } } \\geq \\frac { \\lambda ^ { 2 } \\epsilon ^ { 2 } } { t } \\right) , } \\\\ & { \\leq \\mathbb { E } \\left( \\displaystyle \\sum _ { i = 1 } ^ { t } \\left( \\bar { ( \\hat { \\nu } _ { y } ^ { \\star } ( j ) - p _ { i } ^ { \\star } ( j ) ) ^ { 2 } } \\geq \\frac { \\lambda ^ { 2 } \\epsilon ^ { 2 } } { \\lambda ^ { 2 } } \\right) \\right) , } \\\\ & { \\leq \\displaystyle \\sum _ { i = 1 } ^ { t } \\mathbb { E } \\left( | | \\hat { \\nu } _ { y } ^ { \\star } ( j ) - p _ { i } ^ { \\star } ( j ) | \\geq \\frac { \\lambda ^ { 2 } } { t } \\right) , } \\\\ & { = \\displaystyle \\sum _ { j = 1 } ^ { t } \\mathbb { E } \\left( \\left| \\sum _ { i = 1 } ^ { t } \\bar { \\lambda } _ { i } ^ { j } - p _ { i } ^ { \\star } ( j ) \\right| \\geq \\frac { \\lambda ^ { 2 } } { t } \\right) , } \\\\ & { \\leq \\displaystyle \\sum _ { j = 1 } ^ { t } \\exp \\left( | \\sum _ { i = 1 } ^ { t } \\bar { \\lambda } _ { i } ^ { j } - p _ { i } ^ { \\star } ( j ) | \\right) \\lesssim \\frac { \\lambda ^ { 2 } } { t } \\int _ { 0 } ^ { t } \\int _ { 0 } ^ { t } \\int _ { 0 } ^ { t } \\hat { \\nu } ( j ) , } \\\\ & { \\leq \\displaystyle \\sum _ { j = 1 } ^ { t } \\exp ( - 2 \\lambda \\hat { \\nu } _ { i } ^ { 2 } \\epsilon ^ { 2 } j ) ^ { 2 } , } \\\\ & { = 2 \\exp ( - 2 \\lambda \\hat { \\nu } _ { i } ^ { 2 } \\epsilon ^ { 2 } j ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            267,
+            315,
+            728,
+            570
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "where we used union bound and Chernoff inequalities. Setting this to $\\delta$ , we get ",
+        "bbox": [
+            171,
+            575,
+            694,
+            592
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c8274a440875c533750d02b5d2c133d4a4cc7dcd669cca04bca7eb7105d3183a.jpg",
+        "text": "$$\ns = \\frac { t ^ { 2 } } { 2 \\lambda ^ { 2 } \\epsilon ^ { 2 } } \\log \\left( \\frac { 2 t } { \\delta } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            423,
+            597,
+            575,
+            632
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "From Lemma 10.1, we know that the optimal generator must satisfy $p _ { y } ^ { g } = \\hat { p } _ { y } ^ { r }$ . By invertibility of $A$ , we know that $p _ { x } ^ { g } = A ^ { - 1 } p _ { y } ^ { g }$ , and that $p _ { x } ^ { r } = A ^ { - 1 } p _ { y } ^ { r }$ . Thus, we obtain that with probability $\\geq 1 - \\delta$ , ",
+        "bbox": [
+            174,
+            645,
+            825,
+            678
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2b0d9f1a2d34dd6eedfd51ceb4b31ec2a21b08bfa2e4a3fcaec52567d32482fc.jpg",
+        "text": "$$\n\\begin{array} { r l } { 2 d _ { T V } ( p _ { z } ^ { \\theta } , p _ { x } ^ { \\theta ^ { \\prime } } ) = \\| p _ { x } ^ { \\theta } - p _ { x } ^ { \\theta ^ { \\prime } } \\| _ { 0 } , } & { } \\\\ & { \\leq \\sqrt { t } \\| p _ { x } ^ { \\theta ^ { \\prime } } - p _ { x } ^ { \\theta ^ { \\prime } } \\| _ { 2 } , } \\\\ & { = \\sqrt { t } \\| A ^ { - } \\boldsymbol { b } _ { y } ^ { \\theta ^ { \\prime } } - p _ { x } ^ { \\theta ^ { \\prime } } \\| _ { 2 } , } \\\\ & { = \\sqrt { t } \\| A ^ { - } \\boldsymbol { b } _ { y } ^ { \\theta ^ { \\prime } } - p _ { x } ^ { \\theta ^ { \\prime } } \\| _ { 2 } , } \\\\ & { = \\sqrt { t } \\| A ^ { - 1 } ( p _ { y } ^ { \\theta ^ { \\prime } } + \\bar { p } _ { y } ^ { \\theta ^ { \\prime } } - p _ { y } ^ { \\theta ^ { \\prime } } ) - p _ { x } ^ { \\theta ^ { \\prime } } \\| _ { 2 } , } \\\\ & { = \\sqrt { t } \\| p _ { x } ^ { \\theta } + A ^ { - 1 } ( \\bar { p } _ { y } ^ { \\theta ^ { \\prime } } - p _ { y } ^ { \\theta ^ { \\prime } } ) - p _ { z } ^ { \\theta ^ { \\prime } } \\| _ { 2 } , } \\\\ & { \\leq \\sqrt { t } \\| A ^ { - 1 } \\| _ { 2 } \\| \\bar { p } _ { y } ^ { \\theta ^ { \\prime } } - p _ { y } ^ { \\theta ^ { \\prime } } \\| _ { 2 } , } \\\\ & { \\leq \\sqrt { t } \\frac { 1 } { \\lambda } \\frac { \\lambda \\epsilon } { \\sqrt { t } } , } \\\\ & { = \\epsilon , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            333,
+            702,
+            663,
+            905
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Now we turn to the specific case of Block-Pixels measurement. We proceed by dividing the set of all possible $| P | ^ { n }$ images into $n + 1$ classes. The $i \\cdot$ -th class has those images that have exactly $i$ pixels with zero value. We sort the images according to their class number (arbitrary ordering within the class) and consider the transition matrix $A$ . Note that given an image from class $i$ it must have $j \\geq i$ zero pixels after the measurement. Also, no image in class $i$ can produce another image in the same class after measurements. Thus, the transition matrix is lower triangular. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Since each pixel is blocked independently with probability $p$ and since there are $n$ pixels, the event that no pixels are blocked occurs with probability $\\left( 1 - p \\right) ^ { n }$ . Thus, every image has at least $\\left( 1 - p \\right) ^ { n }$ chance of being unaffected by the measurements. Any unaffected image maps to itself and thus forms diagonal entries in the transition matrix. So, we observe that the diagonal entries of the transition matrix are strictly positive and their minimum value is $\\left( 1 - p \\right) ^ { n }$ . ",
+        "bbox": [
+            174,
+            194,
+            825,
+            263
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "For a triangular matrix, the diagonal entries are precisely the eigenvalues and hence we have proved that $A$ is invertible and the smallest eigenvalue is $( 1 { \\overset { \\cdot } { - } } p ) ^ { n }$ . Combined with the result above, by setting $\\lambda = ( 1 - p ) ^ { n }$ , and $t = | P | ^ { n }$ , we conclude the proof. ",
+        "bbox": [
+            174,
+            271,
+            823,
+            313
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX B ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            354,
+            281,
+            371
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "10.5 MODEL ARCHITECTURE DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            386,
+            454,
+            400
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "The DCGAN model on MNIST follows the architecture in [Radford et al. (2015)]. The noise input to the generator $( Z )$ has 100 dimensions where each coordinate is sampled IID Uniform on $[ - 1 , 1 ]$ . The generator uses two linear layers followed by two deconvolutional layers. The labels are concatenated with the inputs of each layer. The discriminator uses two convolutional layers followed by two linear layers. As with the generator, the labels are concatenated with the inputs of each layer. Batch-norm is used in both generator and the discriminator. ",
+        "bbox": [
+            174,
+            411,
+            825,
+            496
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "The WGANGP model on MNIST follows the architecture in [Gulrajani et al. (2017)]. The generator takes in a latent vector of 128 dimensions where each coordinate is sampled IID Uniform on $[ - 1 , 1 ]$ . The generator then applies one linear and three deconvolutional layers. The discriminator uses three convolutional layers followed by one linear layer. Batch-norm is not used. ",
+        "bbox": [
+            174,
+            502,
+            825,
+            559
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "The unconditional DCGAN model on celebA follows the architecture in [Radford et al. (2015)]. The latent vector has 100 dimensions where each coordinate is Uniform on $[ - 1 , 1 ]$ . The generator applies one linear layer followed by four deconvolutional layers. The discriminator uses four convolutional layers followed by a linear layer. Batch-norm is used in both generator and the discriminator. ",
+        "bbox": [
+            174,
+            565,
+            825,
+            621
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "The ACWGANGP model on CIFAR-10 follows the residual architecture in [Gulrajani et al. (2017)]. The latent vector has 128 dimensions where each coordinate is sampled from IID standard Gaussian distribution. The generator has a linear layer followed by three residual blocks. Each residual block consists of two repetitions of the following three operations: conditional batch normalization followed by a nonlinearity followed by an upconvolution layer. The residual blocks are followed by another conditional batch normalization, a final convolution, and a final tanh non-linearity. The discriminator consists of one residual block with two convolutional layers followed by three residual blocks, and a final linear layer. ",
+        "bbox": [
+            174,
+            628,
+            825,
+            739
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX C ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            760,
+            282,
+            776
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Here, we present some more results for various measurement models. ",
+        "bbox": [
+            178,
+            792,
+            630,
+            806
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/ca7d06add2dfe80f231edc8a658745c4533b88b44935c836971a3e73f33713e8.jpg",
+        "image_caption": [
+            "Figure 9: Results on MNIST with (a) Keep-Patch, and (b) Extract-Patch "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            112,
+            823,
+            280
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/c5b12e085f576ef22d46caec7cca7183e549a6388d8f8107ea1b90e57b867b81.jpg",
+        "image_caption": [
+            "Figure 10: Results with Convolve+Noise on MNIST. Each image is blurred with a Gaussian kernel of radius 1 pixel and noise of std dev $\\sigma$ is added. Rows from top to bottom have $\\sigma = 0 . 0$ , 0.1, 0.2, and 0.5 respectively. Columns from left to right are: (1) Samples of lossy measurements. (2) Samples produced by ignore baseline. (3) Samples produced by unmeasure-wiener-deconvolution baseline. (4) Samples produced by our model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            339,
+            816,
+            827
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/f6cf191d70deb607a85f427333ec6a0581f3aa269a992cdeca12b264a59eaaea.jpg",
+        "image_caption": [
+            "Figure 11: Results with Block-Pixels on MNIST. Rows from top to bottom have blocking probability 0.1, 0.5, 0.8, 0.9, 0.95 and 0.99 respectively. Columns from left to right are: (1) Samples of lossy measurements. (2) Samples produced by unmeasure-blur baseline. (3) Samples produced by unmeasure-inpaint-total-variation baseline. (4) Samples produced by our model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            116,
+            816,
+            845
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/598e9bf15f2976333e628b0c3515b8d086624e240c50a6a350c5d6db0bd00321.jpg",
+        "image_caption": [
+            "Figure 12: Results with Block-Patch on MNIST. (left) Samples of lossy measurements. A randomly chosen $1 4 \\times 1 4$ patch is set to zero. (middle) Samples produced by unmeasure-navier-stokesinpainting baseline. (right) Samples produced by the our model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            256,
+            121,
+            741,
+            244
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/8e787131d99403a6eac017a3188005f1ed0fc521dc0acba534fd1cda9ed88ef4.jpg",
+        "image_caption": [
+            "Figure 13: Results with Convolve+Noise on celebA. Each image is blurred with a Gaussian kernel of radius 1 pixel and noise of std dev $\\sigma$ is added. Rows from top to bottom have $\\sigma = 0 . 0$ , 0.1, and 0.2 respectively. The left column shows samples of lossy measurements. The right column shows samples produced by our model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            289,
+            347,
+            709,
+            832
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/1129973e5b8c1e39e867b6c0018b3e34038ce4ecc0621896cc7c966320800e08.jpg",
+        "image_caption": [
+            "Figure 14: Results with Block-Pixels on celebA. Rows from top to bottom have blocking probability 0.5, 0.8, 0.9, and 0.98 respectively. The left column shows samples of lossy measurements. The right column shows samples produced by our model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            289,
+            162,
+            709,
+            808
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "image",
+        "img_path": "images/3e6bf86af14d4d2e9b35a26e048363cd88fce4af2dd6af479c4dc788b8331634.jpg",
+        "image_caption": [
+            "Figure 15: Results with Block-Pixels on CIFAR-10. Rows from top to bottom have blocking probability 0.1, 0.5, 0.9, and 0.95 respectively. Columns from left to right are: (1) Samples of lossy measurements. (2) Samples produced by unmeasure-blur baseline. (3) Samples produced by our model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            148,
+            813,
+            803
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "image",
+        "img_path": "images/b81a0314ccd3cda163b7a016813a2544750f870c2e9b1414b33b4095d046b219.jpg",
+        "image_caption": [
+            "Figure 16: MNIST with WGANGP (left) Robustness experiment with Block-Pixels measurement (right) Compressed sensing using AmbientGAN. Vertical bars indicate $9 5 \\%$ confidence intervals. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            140,
+            810,
+            311
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "text",
+        "text": "10.6 ROBUSTNESS TO MEASUREMENT MODEL MISMATCH ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            383,
+            584,
+            397
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "text",
+        "text": "So far, in our analysis and experiments, we assumed that the parametric form of the measurement function and the distribution of those parameters is exactly known. This was then used for simulating the stochastic measurement process. Here, we consider the case where the parameter distribution is only approximately known. In this case, one would like the training process to be robust, i.e. the quality of the learned generator to be close to the case where the parameter distribution is exactly known. Through the following experiment, we empirically demonstrate that the AmbientGAN approach is robust to systematic mismatches in the parameter distribution of the measurement function. ",
+        "bbox": [
+            174,
+            409,
+            825,
+            507
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "text",
+        "text": "Consider the Block-Pixels measurement model (Section 4). We use the MNIST dataset. Pixels are blocked with probability $p ^ { * } = 0 . 5$ to obtain a dataset of measurements. For several values of blocking probability $p$ for the measurement function applied to the output of the generator, we train AmbientGAN models with this dataset. After training, we compute the inception score of the learned generators and plot it as a function of $p$ in Fig. 16 (left). We note that the plot peaks at $p = p ^ { * } = 0 . 5$ and gradually drops on both sides. This suggests that our method is somewhat robust to parameter distribution mismatch. ",
+        "bbox": [
+            174,
+            513,
+            825,
+            611
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "text",
+        "text": "10.7 COMPRESSED SENSING USING AMBIENTGAN ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            628,
+            540,
+            642
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "text",
+        "text": "We provide further evidence that the generator learned through AmbientGAN approach captures the data distribution well. Generative models have been shown to improve sensing over sparsitybased approaches [Bora et al. (2017)]. We attempt to use the GAN learned using our procedure for compressed sensing. ",
+        "bbox": [
+            174,
+            654,
+            825,
+            710
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "text",
+        "text": "We trained an AmbientGAN with Block-Pixels measurement model (Section 4) on MNIST with $p = 0 . 5$ . Using the learned generator, we followed the rest of the procedure in [Bora et al. (2017)] using their code3. Fig. 16 (right) shows a plot of reconstruction error vs the number of measurements, comparing Lasso with AmbienGAN. Thus, we observe a similar reduction in the number of measurements while using AmbientGAN trained with corrupted samples instead of a regular GAN trained with fully observed samples. ",
+        "bbox": [
+            173,
+            717,
+            825,
+            800
+        ],
+        "page_idx": 21
+    }
+]

parse/train/IpmfpAGoH2KbX/IpmfpAGoH2KbX.md

@@ -0,0 +1,130 @@
+# Deep learning and the renormalization group
+
+# Cedric B ´ eny ´
+
+Institut fur Theoretische Physik ¨ Leibniz Universitat Hannover ¨ Appelstraße 2, 30167 Hannover, Germany cedric.beny@gmail.com
+
+# Abstract
+
+Renormalization group (RG) methods, which model the way in which the effective behavior of a system depends on the scale at which it is observed, are key to modern condensed-matter theory and particle physics. We compare the ideas behind the RG on the one hand and deep machine learning on the other, where depth and scale play a similar role. In order to illustrate this connection, we review a recent numerical method based on the RG—the multiscale entanglement renormalization ansatz (MERA)—and show how it can be converted into a learning algorithm based on a generative hierarchical Bayesian network model. Under the assumption—common in physics—that the distribution to be learned is fully characterized by local correlations, this algorithm involves only explicit evaluation of probabilities, hence doing away with sampling.
+
+Natural sciences extend the process by which we intuitively discover patterns in our sensory data to domains beyond our natural sensory abilities, but also beyond our intuitive reasoning abilities. Already, machine learning methods are becoming important in fields where the patterns are too complex to be modeled with simple equations, and too far removed from intuition to be comprehended without formal tools.
+
+Physics may seem an unlikely candidate for application of machine learning, given that it specifically focuses on systems which can be understood with simple laws. Nevertheless, these very compact laws have to be compared to experiments, and hence require a “decompression” process which rapidly leads to overwhelming levels of complexity.
+
+The renormalization group (RG) was designed to handle some of these complexities and had a tremendous influence in particle physics and condensed-matter physics [1]. It models the dependence of a system’s effective behavior on a parameter which is usually thought of as scale or energy, but which we will think of here as depth. Although the RG idea is not recent, new approaches have emerged which have the potential to fully automatize it [2–5]. These methods are designed for simulation rather than learning, but, because they are defined through clever representations of certain classes of (quantum) states, they can be adapted to learning tasks as well [6, 7].
+
+In this paper, I will explain how one of these methods (the multiscale entanglement renormalization ansatz [8]) can be made into a deep learning algorithm for classical probability distributions, assuming no prior knowledge of RG or MERA, nor of quantum mechanics. The machine learning framework task that I am considering is that of building a representation of a probability distribution which optimizes the likelihood of the training data.
+
+# 1 The renormalization group
+
+Let us take the point of view of condensed matter physics, where the system of interest is a $d$ - dimensional lattice which we think of as a graph $\Gamma$ which could be embedded in $\mathbb { R } ^ { d }$ in such a way that the edges loosely indicate proximity of sites. Hence we can think of it as a discrete version of a $d$ -dimensional space. We take the graph as fixed once and for all, but we associate with each vertex $v$ , which we call a site, a random variable $X _ { v }$ which can take any of $n$ possible values. The joint probability distribution for all these variables will be referred to as the lattice’s state, and is the object that we want to model.
+
+In the context of machine learning, an example would be a probability distribution over images. In this example, the dimension is $d = 2$ , the sites are pixels linked to their four neighbors, and the random variables are the pixels color values.
+
+Physicists are often interested in such system at thermal equilibrium, where the state can be encoded in a ridiculously compact way through the system’s Hamiltonian, or energy function, which is proportional to the logarithm of the probability distribution. What makes this description compact is that the Hamiltonian is usually a sum of local functions, i.e., functions which depend only on a little group of neighboring sites. Hence, the state is a Markov random field with respect to the graph $\Gamma$ .
+
+However, deducing any property of the state from the Hamiltonian (such as marginal probabilities) is generally very difficult. In fact, the large majority of the work done in theoretical physics is purely concerned with doing just that: deriving approximate properties of systems whose state is defined by a given Hamiltonian, i.e., decompressing the Hamiltonian description, so that predictions can be compared to experiments. In this sense, the Hamiltonian, although it is a compact representation of the state, is not very useful as a representation of what one knows about the system’s properties.
+
+A Hamiltonian is not, however, entirely useless. Given a Hamiltonian, it is relatively easy to make predictions about short-range correlations. For instance, by sampling the distribution using a MonteCarlo simulation. However, the computational cost grows exponentially with the range of the correlations.
+
+The RG approach is based on the observation that longer range correlations can often be summarized by an effective Hamiltonian on a smaller array of coarse-grained random variables which are, for instance, averages of neighboring sites. That is, one can build a stochastic map from the state of the system to that of coarser array of new variables in such a way that the new state can also be described by a local Hamiltonian. This process can be iterated, leading to a hierarchy of effective Hamiltonians labeled by a scale. This family, if it could be computed, would provide an efficient encoding of the system’s behavior at all scales.
+
+The actual choice of “binning”, i.e., the form of the stochastic maps which implement the coarsegrainings, is an essential element of the process, as it selects the proper, emergent, order parameters which contain non-trivial information about the large-scale properties of the system. One may think of these local order parameters as higher-order concepts needed to understand the full state. Typically, the only variables left at the largest scale are the thermodynamic variables which are averages over the whole system. If the coarse-graining procedure is chosen correctly, those variables should identify in which thermodynamic phase the system finds itself.
+
+This hierarchical scale-by-scale encoding of a probability distribution resembles, for instance, a deep encoding of an image whose features are defined by iteratively combining locale patterns into more complex—and larger—patterns. Where this analogy fails, however, is that the distribution to be learned in the context of image recognition is likely not generated by a local Hamiltonian. Nevertheless, we may still think of a local Hamiltonian which appropriately reproduces the shortrange correlations within neighboring pixels. For instance, this Hamiltonian could assign higher probabilities to edge filters. The edge orientations themselves may then be the next coarser variables governed by their own effective Hamiltonian which prefers certain assembly of neighboring edges, and so on until, at the deepest level, the only variables left encodes what the whole image represents, with an effective Hamiltonian yielding the relative frequency of the different classes in the learning data.
+
+The renormalization “group” denotes the set of coarse-graining operations with composition as group operation, although it is rarely a group given that its elements typically have no inverse, and cannot all be composed together. It is more fruitful to think of it as a flow on the “manifold” of Hamiltonians (assuming a continuum of scales), where each possible Hamiltonian flows toward its effective version at larger and larger scales. This picture, however, relies on the Hamiltonian uniquely defining the state, and must be given up if we trust the Hamiltonians to encode only the short-range correlations.
+
+The previous discussion is rather idealized, as a lot of work is needed to transform these ideas into concrete methods. This is why most techniques classified under the umbrella of RG are very modelspecific and hence of little use for us.
+
+However, the study of quantum phase transitions (i.e. phase transitions at zero temperatures, where all fluctuations are quantum instead of thermal) has motivated the appearance of much more generic numerical methods based on an ansatz, i.e., a parameterization of a manageably small set of states which happen to nearly contain many of the interesting physical states. For instance, the very successful density-matrix renormalization group (DMRG) can be understood as an optimization method within the matrix product state (MPS) ansatz. Classically, an MPS can be thought of as a type of stochastic finite-state machine (although another classical version has been proposed [9]). This, however, only works on one-dimensional systems, at least in the quantum setting. In addition, the connection with the RG is somewhat weak (even though it is faithful to a proposal made in the seminal paper by Wilson on the renormalization group [1]).
+
+Here, we will consider instead a more recent proposal which can be formulated in any dimension, and which more directly incorporates the idea of a multiscale description of the system.
+
+# 2 Stochastic version of MERA
+
+The multiscale entanglement renormalization ansatz (MERA) is an efficient parametrization of a certain subset of quantum states (which one may think of as probability distributions but where the probabilities take complex values). It is numerically efficient in two ways which are important for its use in physics. Firstly, the number of parameters involved typically grows linearly with the number $N$ of sites. Secondly, marginal distributions over a constant number of sites (not necessarily contiguous) can be explicitly computed in a time of order $\log N$ .
+
+Instead of describing the full quantum MERA, I will only introduce a classical version of it. Since all entanglement (a.k.a. quantum correlations) is replaced by classical correlations, let us call it the correlation renormalization ansatz (CORA).
+
+For simplicity, I will describe the model as it would apply to data living on a square $d$ -dimensional lattice, such as a time series for $d = 1$ or an image for $d = 2$ , and assume a renormalization model where the coarse-graining is done by grouping blocks of $2 \times 2 \times . . . = 2 ^ { d }$ neighboring sites. Generalization to other lattices or other coarse-graining scheme are rather straightforward.
+
+Instead of starting with an algorithm per se, we start with a “knowledge representation”, that is, a parameterization of a certain set of probability distributions on the observed data. Provided that this parameterization can be stored efficiently, and that the cost function for the learning process be computable efficiently, then an algorithm can be devised to minimize the cost function.
+
+We call $\Gamma _ { 0 }$ the original square lattice on which the data lives, and $\Gamma _ { j }$ , $j = 1 , 2 , \dots$ the successive coarse-graining of that lattice. Each site of $\Gamma _ { j }$ must be thought of as representing a block of $2 ^ { d }$ sites of $\Gamma _ { j - 1 }$ , in the sense that the neighborhood relations between the sites of $\Gamma _ { j }$ represent that of the corresponding blocks on $\Gamma _ { j - 1 }$ .
+
+Since the number of sites of $\Gamma _ { j }$ is a constant fraction of that of $\Gamma _ { j - 1 }$ $( 1 / 2 ^ { d }$ in this case), the total number of coarse-graining steps is logarithmic in the total size $N$ of $\Gamma _ { 0 }$ , i.e. in the total number of variables.
+
+By a state on $\Gamma _ { j }$ , we refer to a joint probability distribution for the values of the variables associated with each site of $\Gamma _ { j }$ . We denote the set of these distributions by $S ( \Gamma _ { j } )$ . The idea is to represent a state $\mu \in S ( \Gamma _ { 0 } )$ through a sequence of stochastic maps
+
+$$
+\pi _ { j } : S ( \Gamma _ { j } ) \to S ( \Gamma _ { j - 1 } )
+$$
+
+$$
+\mu = \pi _ { 1 } \circ \pi _ { 2 } \circ \ldots \circ \pi _ { j _ { \mathrm { m a x } } } ( e ) ,
+$$
+
+where $\circ$ denotes composition, and $e$ is some fiducial state on the coarsest lattice $\Gamma _ { j _ { \mathrm { m a x } } }$ , e.g., the uniform distribution. In the original MERA, these maps $\pi _ { j }$ are isometric operator on a Hilbert space, which is the quantum equivalent of stochastic maps, in the sense that they are the most general maps preserving the basic properties of the states.
+
+![](images/5d836d86583635f9820878b24931dfcfa3dbc9596025711633050c9d94bc1956.jpg)  
+Figure 1: Example of a MERA for a one-dimensional lattice, where only two layers are represented. The boxes and triangles are arbitrary isometric maps between Hilbert spaces represented by the vertical lines. We obtain a CORA by replacing the boxes and triangles by stochastic maps between random variables. This diagram can then be read as an operational recipe to produce the state on the lattice $\Gamma _ { 0 }$ , from that of $\Gamma _ { 2 }$ : each vertical line represents some data, or random variable, and a box or triangle is a specific stochastic map which must be applied to the joint probability distribution of all its input(s) (the lines coming in from above) in order to produce the joint distribution of its outputs (represented by the lines coming out below it). This can be equivalently represented by the Bayesian network of Figure 2. The parameters of the model are the components of all the local stochastic maps (boxes and triangles), together with the initial state of the last layer $\Gamma _ { j _ { \mathrm { m a x } } }$ .
+
+One may think of these $\pi _ { j }$ as the inverse of the coarse-graining channels defining the renormalization group. Indeed, instead of destroying information by mapping a precise lattice to a coarser one with fewer sites, it introduces information by creating additional sites, hence constructing the full state scale by scale. In this sense, MERA is a “generative” interpretation of the RG.
+
+In the original MERA, these maps are specifically required to be implementable by local maps (stochastic maps in the classical case or isometries in the quantum case), such as represented in Figures 1 and 2 for a one-dimensional lattice. Such a given structure being fixed, the variational parameters left to be learned are the components of each local map.
+
+The required decomposability of the maps $\pi _ { j }$ into local operations renders the number of variational parameters linear in the lattice size. Apart from this, however, the particular way in which the local maps are combined is not essential, except for the causal properties of the complete maps $\pi _ { j }$ allowed: Firstly, $\pi _ { j } : S ( \Gamma _ { j } ) \to S ( \Gamma _ { j - 1 } )$ must be such that, through it, each site of $\Gamma _ { j }$ can only causally influence the block of sites of $\Gamma _ { j - 1 }$ that it represents, or their neighbors as well, up to a constant distance. In Figure 1 for instance, it is apparent that a given site can only influence the values of the block of two sites that it represents, immediately below it, together with their nearest neighbors.
+
+The concept of causality that is used is defined as follows: for a given stochastic matrix with several input and output variables, we say that the $i$ th input cannot causally influence the $j$ th output if the variable $i$ is not required for the calculation of the marginal over $j$ , no matter what the complete input is. That is, the marginal over $j$ can be computed purely from the marginal over all original input variables but the ith.
+
+Secondly, something which is also apparent in Figure 1, is the fact that $\pi _ { j }$ cannot introduce any correlations between far-away sites if its input is uncorrelated, where “far-away” means that these output sites cannot be influenced by the same input site, in terms of the first causality condition.
+
+It is in this sense that each layer $\pi _ { j }$ can only create, and therefore represent, correlations at a given scale.
+
+![](images/612ca86be3b7f2de0d843d807e4d1066501eff814882cc80508e2d84a55f8e3f.jpg)  
+Figure 2: Example of Figure 1 represented as a Bayesian network (only two layers are represented). The bottom nodes are observed. Note that the graph is truncated, as the nodes of $\Gamma _ { 2 }$ must be linked to the next layer which is not represented, as well as to each other, in the same manner as the two layers below it.
+
+![](images/e8118b83c54c0b2d70f1a54521d23c2d746125eaad7ad4f4cdfde4b8503f7e9e.jpg)  
+Figure 3: Stochastic maps involved in the last two steps of the computation of the marginal state on 3 consecutive output sites. The lines ending abruptly indicates that the corresponding variable is summed over. The “past” of any region of $\Gamma _ { 0 }$ of size $L$ always involves just 3 sites before level Γ[log2(L)].
+
+# 3 Learning CORA
+
+The causal properties inherent in the definition of MERA/CORA imply that a marginal over any finite group of $L$ sites can be computed (explicitly, i.e., without sampling) in a time of order $e ^ { L } \log ( N )$ . Indeed, due to the particular causal structure of the maps $\pi _ { j }$ , the past of any set of sites of $\Gamma _ { j }$ , namely those sites of $\Gamma _ { j + 1 }$ on which their values depend explicitly through $\pi _ { j }$ , always ends up involving a constant number of sites independent of $N$ (and generally manageably small). This is illustrated in Figure 3.
+
+In the quantum physical setting for which MERA was introduced, the state that we want to represent is not defined by samples, but instead by a Hamiltonian, or energy function, that it minimizes, i.e., the cost function itself. Most often, the Hamiltonians considered are local, which implies that the evaluation of their expectation only requires the use of marginal states over small clusters of neighboring sites. Therefore the cost function can be evaluated efficiently and exactly.
+
+Such a procedure can be adapted to a situation where, instead of being handed the Hamiltonian, we are given samples from the unknown distribution: the training data. In physics, this situation presents itself when an experimentalists wants to reconstruct a state that he has access to only through experiments (which yields the samples), a process which is called “state tomography”. This is, of course, no different from a typical learning task.
+
+A difference, however, is that in physics one is often interested in states which minimize some unknown local Hamiltonian. This assumptions implies that it is sufficient to work with the efficiently computable marginals over small groups of neighboring sites (so called reduced states in quantum theory). Therefore, we can set the parameters of the channels $\pi _ { j }$ by maximizing the probabilities that these reduced states assign to the training data. In the quantum context, this was proposed in Ref. [7]. For CORA, the cost function can be calculated in the same way, but the optimization procedure must be slightly modified to account for the fact that the constraints on the stochastic maps components are different from the quantum MERA.
+
+# 3.1 States not determined by local laws
+
+It is clear, however, that a MERA, or CORA, can represent a much vaster class of states, in particular states whose long-range correlation structure is not determined by the nature of the short range correlations, such as one would expect for natural or artificial images for instance. Indeed, the components of the stochastic maps $\pi _ { j }$ can be modified directly at any scale $j$ with minimal effect on the short range correlations.
+
+Let us therefore consider learning in the more general situation. Mirroring our discussion of section 1, we can still use the efficiently computable local reduced states in order to optimize the component of the first channel $\pi _ { 1 }$ , since it cannot anyway encode information about longer ranged correlations. We say that we are working with training length $\epsilon _ { \mathrm { 0 } }$ , ignoring all correlations in the data at larger lengthscales.
+
+This can be done in two different ways. We may simply optimize $\pi _ { 1 }$ by locally comparing the training data to $\pi _ { 1 } ( e )$ where $e$ is the uniform distribution, or any other prior (method 1), or we can already optimize all layers simultaneously as would be done for a tomography problem, focusing only on short-range correlation (method 2). This would have the advantage of already making long range—or deep—deductions from the data. For instance, if all neighboring pixels were the same color, this would already deduce that the whole image is uniform.
+
+In a second pass, we need to compare the data to marginals generated over the new training length $\epsilon _ { 1 }$ associated with the next channel $\pi _ { 2 }$ . We do not want to do this by comparing the data to the full candidate state generated at the level of $\Gamma _ { 0 }$ , as the number of sites involved would grow by a factor $2 ^ { d }$ with a bad exponential increase in complexity. Instead, we want to directly compare the reduced state at level $\Gamma _ { 1 }$ to a coarse-grained (i.e., “renormalized”) version of the training data at that level.
+
+Performing this step is where the difficulties lie, and could likely not be done quantum mechanically. Classically, however, it may be possible to use sampling in this step. This coarse-graining must be done by the Bayesian inverse of $\pi _ { 1 }$ , with prior $e$ (method 1), or a prior generated by the previous layers (method 2), which is possible because we really only need the prior over scale $\epsilon _ { 1 }$ . An example of the type of Bayesian networks involved is represented in Figure 2.
+
+This process can be iterated until all ${ \mathcal { O } } ( \log N )$ layers/channels have been trained, and the training length covers the whole system. Further training passes can then be done in the same way in order to exploit the better priors generated by the already trained layers.
+
+# Acknowledgments
+
+Helpful discussions with Tobias Osborne are gratefully acknowledged. This work was supported by the cluster of excellence EXC 201 “Quantum Engineering and Space-Time Research”.
+
+# References
+
+[1] K.G. Wilson. The renormalization group and critical phenomena. Rev. Mod. Phys., 55(3):583, 1983. [2] G. Vidal. Entanglement renormalization. Physical Review Letters, 99:220405, 2007.
+
+[3] G. Vidal. Class of quantum many-body states that can be efficiently simulated. Phys. Rev. Lett., 101:110501, 2008.   
+[4] D. Perez-Garcia, F. Verstraete, M.M. Wolf, and J.I. Cirac. ArXiv:quant-ph/0608197, 2006.   
+[5] F. Verstraete, M.M. Wolf, D. Perez-Garcia, and J.I. Cirac. Criticality, the area law, and the computational power of projected entangled pair states. Phys. Rev. Lett., 96(22):220601, 2006.   
+[6] M. Cramer, M. B. Plenio, S. T. Flammia, R. Somma, D. Gross, S. D. Bartlett, O. LandonCardinal, D. Poulin, and Y.-K. Liu. Efficient quantum state tomography. Nature Communications, 2010.   
+[7] O. Landon-Cardinal and D. Poulin. Practical learning method for multi-scale entangled states. New Journal of Physics, 2012.   
+[8] G. Vidal. Entanglement Renormalization: an introduction. ArXiv:0912.1651, 2009.   
+[9] Kristan Temme and Frank Verstraete. Stochastic matrix product states. Phys. Rev. Lett., 104:210502, 2010.

parse/train/IpmfpAGoH2KbX/IpmfpAGoH2KbX_content_list.json

@@ -0,0 +1,720 @@
+[
+    {
+        "type": "text",
+        "text": "Deep learning and the renormalization group ",
+        "text_level": 1,
+        "bbox": [
+            223,
+            135,
+            772,
+            160
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Cedric B ´ eny ´ ",
+        "text_level": 1,
+        "bbox": [
+            457,
+            213,
+            544,
+            227
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Institut fur Theoretische Physik ¨ Leibniz Universitat Hannover ¨ Appelstraße 2, 30167 Hannover, Germany cedric.beny@gmail.com ",
+        "bbox": [
+            361,
+            228,
+            637,
+            284
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            319,
+            535,
+            335
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Renormalization group (RG) methods, which model the way in which the effective behavior of a system depends on the scale at which it is observed, are key to modern condensed-matter theory and particle physics. We compare the ideas behind the RG on the one hand and deep machine learning on the other, where depth and scale play a similar role. In order to illustrate this connection, we review a recent numerical method based on the RG—the multiscale entanglement renormalization ansatz (MERA)—and show how it can be converted into a learning algorithm based on a generative hierarchical Bayesian network model. Under the assumption—common in physics—that the distribution to be learned is fully characterized by local correlations, this algorithm involves only explicit evaluation of probabilities, hence doing away with sampling. ",
+        "bbox": [
+            233,
+            353,
+            764,
+            506
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Natural sciences extend the process by which we intuitively discover patterns in our sensory data to domains beyond our natural sensory abilities, but also beyond our intuitive reasoning abilities. Already, machine learning methods are becoming important in fields where the patterns are too complex to be modeled with simple equations, and too far removed from intuition to be comprehended without formal tools. ",
+        "bbox": [
+            174,
+            526,
+            823,
+            594
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Physics may seem an unlikely candidate for application of machine learning, given that it specifically focuses on systems which can be understood with simple laws. Nevertheless, these very compact laws have to be compared to experiments, and hence require a “decompression” process which rapidly leads to overwhelming levels of complexity. ",
+        "bbox": [
+            174,
+            603,
+            823,
+            659
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The renormalization group (RG) was designed to handle some of these complexities and had a tremendous influence in particle physics and condensed-matter physics [1]. It models the dependence of a system’s effective behavior on a parameter which is usually thought of as scale or energy, but which we will think of here as depth. Although the RG idea is not recent, new approaches have emerged which have the potential to fully automatize it [2–5]. These methods are designed for simulation rather than learning, but, because they are defined through clever representations of certain classes of (quantum) states, they can be adapted to learning tasks as well [6, 7]. ",
+        "bbox": [
+            174,
+            665,
+            825,
+            763
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, I will explain how one of these methods (the multiscale entanglement renormalization ansatz [8]) can be made into a deep learning algorithm for classical probability distributions, assuming no prior knowledge of RG or MERA, nor of quantum mechanics. The machine learning framework task that I am considering is that of building a representation of a probability distribution which optimizes the likelihood of the training data. ",
+        "bbox": [
+            174,
+            770,
+            823,
+            840
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 The renormalization group ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            861,
+            431,
+            880
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Let us take the point of view of condensed matter physics, where the system of interest is a $d$ - dimensional lattice which we think of as a graph $\\Gamma$ which could be embedded in $\\mathbb { R } ^ { d }$ in such a way that the edges loosely indicate proximity of sites. Hence we can think of it as a discrete version of a $d$ -dimensional space. We take the graph as fixed once and for all, but we associate with each vertex $v$ , which we call a site, a random variable $X _ { v }$ which can take any of $n$ possible values. The joint probability distribution for all these variables will be referred to as the lattice’s state, and is the object that we want to model. ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the context of machine learning, an example would be a probability distribution over images. In this example, the dimension is $d = 2$ , the sites are pixels linked to their four neighbors, and the random variables are the pixels color values. ",
+        "bbox": [
+            176,
+            180,
+            821,
+            222
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Physicists are often interested in such system at thermal equilibrium, where the state can be encoded in a ridiculously compact way through the system’s Hamiltonian, or energy function, which is proportional to the logarithm of the probability distribution. What makes this description compact is that the Hamiltonian is usually a sum of local functions, i.e., functions which depend only on a little group of neighboring sites. Hence, the state is a Markov random field with respect to the graph $\\Gamma$ . ",
+        "bbox": [
+            174,
+            229,
+            825,
+            299
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "However, deducing any property of the state from the Hamiltonian (such as marginal probabilities) is generally very difficult. In fact, the large majority of the work done in theoretical physics is purely concerned with doing just that: deriving approximate properties of systems whose state is defined by a given Hamiltonian, i.e., decompressing the Hamiltonian description, so that predictions can be compared to experiments. In this sense, the Hamiltonian, although it is a compact representation of the state, is not very useful as a representation of what one knows about the system’s properties. ",
+        "bbox": [
+            174,
+            306,
+            825,
+            390
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A Hamiltonian is not, however, entirely useless. Given a Hamiltonian, it is relatively easy to make predictions about short-range correlations. For instance, by sampling the distribution using a MonteCarlo simulation. However, the computational cost grows exponentially with the range of the correlations. ",
+        "bbox": [
+            174,
+            396,
+            823,
+            452
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The RG approach is based on the observation that longer range correlations can often be summarized by an effective Hamiltonian on a smaller array of coarse-grained random variables which are, for instance, averages of neighboring sites. That is, one can build a stochastic map from the state of the system to that of coarser array of new variables in such a way that the new state can also be described by a local Hamiltonian. This process can be iterated, leading to a hierarchy of effective Hamiltonians labeled by a scale. This family, if it could be computed, would provide an efficient encoding of the system’s behavior at all scales. ",
+        "bbox": [
+            174,
+            459,
+            825,
+            556
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The actual choice of “binning”, i.e., the form of the stochastic maps which implement the coarsegrainings, is an essential element of the process, as it selects the proper, emergent, order parameters which contain non-trivial information about the large-scale properties of the system. One may think of these local order parameters as higher-order concepts needed to understand the full state. Typically, the only variables left at the largest scale are the thermodynamic variables which are averages over the whole system. If the coarse-graining procedure is chosen correctly, those variables should identify in which thermodynamic phase the system finds itself. ",
+        "bbox": [
+            174,
+            564,
+            823,
+            661
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This hierarchical scale-by-scale encoding of a probability distribution resembles, for instance, a deep encoding of an image whose features are defined by iteratively combining locale patterns into more complex—and larger—patterns. Where this analogy fails, however, is that the distribution to be learned in the context of image recognition is likely not generated by a local Hamiltonian. Nevertheless, we may still think of a local Hamiltonian which appropriately reproduces the shortrange correlations within neighboring pixels. For instance, this Hamiltonian could assign higher probabilities to edge filters. The edge orientations themselves may then be the next coarser variables governed by their own effective Hamiltonian which prefers certain assembly of neighboring edges, and so on until, at the deepest level, the only variables left encodes what the whole image represents, with an effective Hamiltonian yielding the relative frequency of the different classes in the learning data. ",
+        "bbox": [
+            174,
+            667,
+            825,
+            820
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The renormalization “group” denotes the set of coarse-graining operations with composition as group operation, although it is rarely a group given that its elements typically have no inverse, and cannot all be composed together. It is more fruitful to think of it as a flow on the “manifold” of Hamiltonians (assuming a continuum of scales), where each possible Hamiltonian flows toward its effective version at larger and larger scales. This picture, however, relies on the Hamiltonian uniquely defining the state, and must be given up if we trust the Hamiltonians to encode only the short-range correlations. ",
+        "bbox": [
+            174,
+            828,
+            825,
+            898
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The previous discussion is rather idealized, as a lot of work is needed to transform these ideas into concrete methods. This is why most techniques classified under the umbrella of RG are very modelspecific and hence of little use for us. ",
+        "bbox": [
+            176,
+            138,
+            821,
+            180
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "However, the study of quantum phase transitions (i.e. phase transitions at zero temperatures, where all fluctuations are quantum instead of thermal) has motivated the appearance of much more generic numerical methods based on an ansatz, i.e., a parameterization of a manageably small set of states which happen to nearly contain many of the interesting physical states. For instance, the very successful density-matrix renormalization group (DMRG) can be understood as an optimization method within the matrix product state (MPS) ansatz. Classically, an MPS can be thought of as a type of stochastic finite-state machine (although another classical version has been proposed [9]). This, however, only works on one-dimensional systems, at least in the quantum setting. In addition, the connection with the RG is somewhat weak (even though it is faithful to a proposal made in the seminal paper by Wilson on the renormalization group [1]). ",
+        "bbox": [
+            174,
+            188,
+            825,
+            327
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here, we will consider instead a more recent proposal which can be formulated in any dimension, and which more directly incorporates the idea of a multiscale description of the system. ",
+        "bbox": [
+            174,
+            334,
+            825,
+            362
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Stochastic version of MERA ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            382,
+            441,
+            398
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The multiscale entanglement renormalization ansatz (MERA) is an efficient parametrization of a certain subset of quantum states (which one may think of as probability distributions but where the probabilities take complex values). It is numerically efficient in two ways which are important for its use in physics. Firstly, the number of parameters involved typically grows linearly with the number $N$ of sites. Secondly, marginal distributions over a constant number of sites (not necessarily contiguous) can be explicitly computed in a time of order $\\log N$ . ",
+        "bbox": [
+            174,
+            412,
+            825,
+            497
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Instead of describing the full quantum MERA, I will only introduce a classical version of it. Since all entanglement (a.k.a. quantum correlations) is replaced by classical correlations, let us call it the correlation renormalization ansatz (CORA). ",
+        "bbox": [
+            176,
+            503,
+            821,
+            546
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For simplicity, I will describe the model as it would apply to data living on a square $d$ -dimensional lattice, such as a time series for $d = 1$ or an image for $d = 2$ , and assume a renormalization model where the coarse-graining is done by grouping blocks of $2 \\times 2 \\times . . . = 2 ^ { d }$ neighboring sites. Generalization to other lattices or other coarse-graining scheme are rather straightforward. ",
+        "bbox": [
+            174,
+            553,
+            825,
+            609
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Instead of starting with an algorithm per se, we start with a “knowledge representation”, that is, a parameterization of a certain set of probability distributions on the observed data. Provided that this parameterization can be stored efficiently, and that the cost function for the learning process be computable efficiently, then an algorithm can be devised to minimize the cost function. ",
+        "bbox": [
+            174,
+            616,
+            825,
+            671
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We call $\\Gamma _ { 0 }$ the original square lattice on which the data lives, and $\\Gamma _ { j }$ , $j = 1 , 2 , \\dots$ the successive coarse-graining of that lattice. Each site of $\\Gamma _ { j }$ must be thought of as representing a block of $2 ^ { d }$ sites of $\\Gamma _ { j - 1 }$ , in the sense that the neighborhood relations between the sites of $\\Gamma _ { j }$ represent that of the corresponding blocks on $\\Gamma _ { j - 1 }$ . ",
+        "bbox": [
+            174,
+            678,
+            825,
+            738
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Since the number of sites of $\\Gamma _ { j }$ is a constant fraction of that of $\\Gamma _ { j - 1 }$ $( 1 / 2 ^ { d }$ in this case), the total number of coarse-graining steps is logarithmic in the total size $N$ of $\\Gamma _ { 0 }$ , i.e. in the total number of variables. ",
+        "bbox": [
+            174,
+            744,
+            825,
+            786
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "By a state on $\\Gamma _ { j }$ , we refer to a joint probability distribution for the values of the variables associated with each site of $\\Gamma _ { j }$ . We denote the set of these distributions by $S ( \\Gamma _ { j } )$ . The idea is to represent a state $\\mu \\in S ( \\Gamma _ { 0 } )$ through a sequence of stochastic maps ",
+        "bbox": [
+            174,
+            794,
+            825,
+            837
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d7544c38e7dda2688298cf395c8cc274accdf0b13cf4fbff29d9b5ed8b2a0e10.jpg",
+        "text": "$$\n\\pi _ { j } : S ( \\Gamma _ { j } ) \\to S ( \\Gamma _ { j - 1 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            419,
+            842,
+            578,
+            859
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ef2a1d877613c123ae500090d9d8315e167ef2f7fc370727d4d89814beb5e9f8.jpg",
+        "text": "$$\n\\mu = \\pi _ { 1 } \\circ \\pi _ { 2 } \\circ \\ldots \\circ \\pi _ { j _ { \\mathrm { m a x } } } ( e ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            877,
+            596,
+            893
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\circ$ denotes composition, and $e$ is some fiducial state on the coarsest lattice $\\Gamma _ { j _ { \\mathrm { m a x } } }$ , e.g., the uniform distribution. In the original MERA, these maps $\\pi _ { j }$ are isometric operator on a Hilbert space, which is the quantum equivalent of stochastic maps, in the sense that they are the most general maps preserving the basic properties of the states. ",
+        "bbox": [
+            173,
+            896,
+            826,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/5d836d86583635f9820878b24931dfcfa3dbc9596025711633050c9d94bc1956.jpg",
+        "image_caption": [
+            "Figure 1: Example of a MERA for a one-dimensional lattice, where only two layers are represented. The boxes and triangles are arbitrary isometric maps between Hilbert spaces represented by the vertical lines. We obtain a CORA by replacing the boxes and triangles by stochastic maps between random variables. This diagram can then be read as an operational recipe to produce the state on the lattice $\\Gamma _ { 0 }$ , from that of $\\Gamma _ { 2 }$ : each vertical line represents some data, or random variable, and a box or triangle is a specific stochastic map which must be applied to the joint probability distribution of all its input(s) (the lines coming in from above) in order to produce the joint distribution of its outputs (represented by the lines coming out below it). This can be equivalently represented by the Bayesian network of Figure 2. The parameters of the model are the components of all the local stochastic maps (boxes and triangles), together with the initial state of the last layer $\\Gamma _ { j _ { \\mathrm { m a x } } }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            235,
+            98,
+            763,
+            289
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            491,
+            823,
+            518
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "One may think of these $\\pi _ { j }$ as the inverse of the coarse-graining channels defining the renormalization group. Indeed, instead of destroying information by mapping a precise lattice to a coarser one with fewer sites, it introduces information by creating additional sites, hence constructing the full state scale by scale. In this sense, MERA is a “generative” interpretation of the RG. ",
+        "bbox": [
+            174,
+            525,
+            825,
+            582
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the original MERA, these maps are specifically required to be implementable by local maps (stochastic maps in the classical case or isometries in the quantum case), such as represented in Figures 1 and 2 for a one-dimensional lattice. Such a given structure being fixed, the variational parameters left to be learned are the components of each local map. ",
+        "bbox": [
+            174,
+            588,
+            825,
+            643
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The required decomposability of the maps $\\pi _ { j }$ into local operations renders the number of variational parameters linear in the lattice size. Apart from this, however, the particular way in which the local maps are combined is not essential, except for the causal properties of the complete maps $\\pi _ { j }$ allowed: Firstly, $\\pi _ { j } : S ( \\Gamma _ { j } ) \\to S ( \\Gamma _ { j - 1 } )$ must be such that, through it, each site of $\\Gamma _ { j }$ can only causally influence the block of sites of $\\Gamma _ { j - 1 }$ that it represents, or their neighbors as well, up to a constant distance. In Figure 1 for instance, it is apparent that a given site can only influence the values of the block of two sites that it represents, immediately below it, together with their nearest neighbors. ",
+        "bbox": [
+            174,
+            651,
+            825,
+            762
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The concept of causality that is used is defined as follows: for a given stochastic matrix with several input and output variables, we say that the $i$ th input cannot causally influence the $j$ th output if the variable $i$ is not required for the calculation of the marginal over $j$ , no matter what the complete input is. That is, the marginal over $j$ can be computed purely from the marginal over all original input variables but the ith. ",
+        "bbox": [
+            174,
+            770,
+            823,
+            839
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Secondly, something which is also apparent in Figure 1, is the fact that $\\pi _ { j }$ cannot introduce any correlations between far-away sites if its input is uncorrelated, where “far-away” means that these output sites cannot be influenced by the same input site, in terms of the first causality condition. ",
+        "bbox": [
+            174,
+            847,
+            823,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "It is in this sense that each layer $\\pi _ { j }$ can only create, and therefore represent, correlations at a given scale. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/612ca86be3b7f2de0d843d807e4d1066501eff814882cc80508e2d84a55f8e3f.jpg",
+        "image_caption": [
+            "Figure 2: Example of Figure 1 represented as a Bayesian network (only two layers are represented). The bottom nodes are observed. Note that the graph is truncated, as the nodes of $\\Gamma _ { 2 }$ must be linked to the next layer which is not represented, as well as to each other, in the same manner as the two layers below it. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            235,
+            95,
+            761,
+            287
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/e8118b83c54c0b2d70f1a54521d23c2d746125eaad7ad4f4cdfde4b8503f7e9e.jpg",
+        "image_caption": [
+            "Figure 3: Stochastic maps involved in the last two steps of the computation of the marginal state on 3 consecutive output sites. The lines ending abruptly indicates that the corresponding variable is summed over. The “past” of any region of $\\Gamma _ { 0 }$ of size $L$ always involves just 3 sites before level Γ[log2(L)]. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            235,
+            377,
+            763,
+            574
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 Learning CORA ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            679,
+            344,
+            696
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The causal properties inherent in the definition of MERA/CORA imply that a marginal over any finite group of $L$ sites can be computed (explicitly, i.e., without sampling) in a time of order $e ^ { L } \\log ( N )$ . Indeed, due to the particular causal structure of the maps $\\pi _ { j }$ , the past of any set of sites of $\\Gamma _ { j }$ , namely those sites of $\\Gamma _ { j + 1 }$ on which their values depend explicitly through $\\pi _ { j }$ , always ends up involving a constant number of sites independent of $N$ (and generally manageably small). This is illustrated in Figure 3. ",
+        "bbox": [
+            173,
+            713,
+            825,
+            797
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the quantum physical setting for which MERA was introduced, the state that we want to represent is not defined by samples, but instead by a Hamiltonian, or energy function, that it minimizes, i.e., the cost function itself. Most often, the Hamiltonians considered are local, which implies that the evaluation of their expectation only requires the use of marginal states over small clusters of neighboring sites. Therefore the cost function can be evaluated efficiently and exactly. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            875
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Such a procedure can be adapted to a situation where, instead of being handed the Hamiltonian, we are given samples from the unknown distribution: the training data. In physics, this situation presents itself when an experimentalists wants to reconstruct a state that he has access to only through experiments (which yields the samples), a process which is called “state tomography”. This is, of course, no different from a typical learning task. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A difference, however, is that in physics one is often interested in states which minimize some unknown local Hamiltonian. This assumptions implies that it is sufficient to work with the efficiently computable marginals over small groups of neighboring sites (so called reduced states in quantum theory). Therefore, we can set the parameters of the channels $\\pi _ { j }$ by maximizing the probabilities that these reduced states assign to the training data. In the quantum context, this was proposed in Ref. [7]. For CORA, the cost function can be calculated in the same way, but the optimization procedure must be slightly modified to account for the fact that the constraints on the stochastic maps components are different from the quantum MERA. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            251
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.1 States not determined by local laws ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            270,
+            457,
+            285
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "It is clear, however, that a MERA, or CORA, can represent a much vaster class of states, in particular states whose long-range correlation structure is not determined by the nature of the short range correlations, such as one would expect for natural or artificial images for instance. Indeed, the components of the stochastic maps $\\pi _ { j }$ can be modified directly at any scale $j$ with minimal effect on the short range correlations. ",
+        "bbox": [
+            174,
+            297,
+            825,
+            367
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Let us therefore consider learning in the more general situation. Mirroring our discussion of section 1, we can still use the efficiently computable local reduced states in order to optimize the component of the first channel $\\pi _ { 1 }$ , since it cannot anyway encode information about longer ranged correlations. We say that we are working with training length $\\epsilon _ { \\mathrm { 0 } }$ , ignoring all correlations in the data at larger lengthscales. ",
+        "bbox": [
+            174,
+            375,
+            825,
+            443
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This can be done in two different ways. We may simply optimize $\\pi _ { 1 }$ by locally comparing the training data to $\\pi _ { 1 } ( e )$ where $e$ is the uniform distribution, or any other prior (method 1), or we can already optimize all layers simultaneously as would be done for a tomography problem, focusing only on short-range correlation (method 2). This would have the advantage of already making long range—or deep—deductions from the data. For instance, if all neighboring pixels were the same color, this would already deduce that the whole image is uniform. ",
+        "bbox": [
+            174,
+            450,
+            825,
+            535
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In a second pass, we need to compare the data to marginals generated over the new training length $\\epsilon _ { 1 }$ associated with the next channel $\\pi _ { 2 }$ . We do not want to do this by comparing the data to the full candidate state generated at the level of $\\Gamma _ { 0 }$ , as the number of sites involved would grow by a factor $2 ^ { d }$ with a bad exponential increase in complexity. Instead, we want to directly compare the reduced state at level $\\Gamma _ { 1 }$ to a coarse-grained (i.e., “renormalized”) version of the training data at that level. ",
+        "bbox": [
+            174,
+            541,
+            825,
+            611
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Performing this step is where the difficulties lie, and could likely not be done quantum mechanically. Classically, however, it may be possible to use sampling in this step. This coarse-graining must be done by the Bayesian inverse of $\\pi _ { 1 }$ , with prior $e$ (method 1), or a prior generated by the previous layers (method 2), which is possible because we really only need the prior over scale $\\epsilon _ { 1 }$ . An example of the type of Bayesian networks involved is represented in Figure 2. ",
+        "bbox": [
+            174,
+            617,
+            825,
+            688
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This process can be iterated until all ${ \\mathcal { O } } ( \\log N )$ layers/channels have been trained, and the training length covers the whole system. Further training passes can then be done in the same way in order to exploit the better priors generated by the already trained layers. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            737
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            760,
+            328,
+            776
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Helpful discussions with Tobias Osborne are gratefully acknowledged. This work was supported by the cluster of excellence EXC 201 “Quantum Engineering and Space-Time Research”. ",
+        "bbox": [
+            171,
+            792,
+            823,
+            821
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            844,
+            266,
+            861
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "[1] K.G. Wilson. The renormalization group and critical phenomena. Rev. Mod. Phys., 55(3):583, 1983. [2] G. Vidal. Entanglement renormalization. Physical Review Letters, 99:220405, 2007. ",
+        "bbox": [
+            173,
+            873,
+            826,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "[3] G. Vidal. Class of quantum many-body states that can be efficiently simulated. Phys. Rev. Lett., 101:110501, 2008.   \n[4] D. Perez-Garcia, F. Verstraete, M.M. Wolf, and J.I. Cirac. ArXiv:quant-ph/0608197, 2006.   \n[5] F. Verstraete, M.M. Wolf, D. Perez-Garcia, and J.I. Cirac. Criticality, the area law, and the computational power of projected entangled pair states. Phys. Rev. Lett., 96(22):220601, 2006.   \n[6] M. Cramer, M. B. Plenio, S. T. Flammia, R. Somma, D. Gross, S. D. Bartlett, O. LandonCardinal, D. Poulin, and Y.-K. Liu. Efficient quantum state tomography. Nature Communications, 2010.   \n[7] O. Landon-Cardinal and D. Poulin. Practical learning method for multi-scale entangled states. New Journal of Physics, 2012.   \n[8] G. Vidal. Entanglement Renormalization: an introduction. ArXiv:0912.1651, 2009.   \n[9] Kristan Temme and Frank Verstraete. Stochastic matrix product states. Phys. Rev. Lett., 104:210502, 2010. ",
+        "bbox": [
+            171,
+            102,
+            826,
+            315
+        ],
+        "page_idx": 6
+    }
+]

parse/train/rkeJRhNYDH/rkeJRhNYDH.md

@@ -0,0 +1,465 @@
+# TABFACT: A LARGE-SCALE DATASET FOR TABLEBASED FACT VERIFICATION
+
+Wenhu Chen, Hongmin Wang, Jianshu Chen, Yunkai Zhang, Hong Wang, Shiyang Li, Xiyou Zhou, William Yang Wang
+
+University of California, Santa Barbara, CA, USA   
+Tencent AI Lab, Bellevue, WA, USA   
+{wenhuchen,hongmin wang,yunkai zhang,hongwang600,william}@ucsb.edu   
+{shiyangli,xiyou}@cs.ucsb.edu jianshuchen@tencent.com
+
+# ABSTRACT
+
+The problem of verifying whether a textual hypothesis holds based on the given evidence, also known as fact verification, plays an important role in the study of natural language understanding and semantic representation. However, existing studies are mainly restricted to dealing with unstructured evidence (e.g., natural language sentences and documents, news, etc), while verification under structured evidence, such as tables, graphs, and databases, remains under-explored. This paper specifically aims to study the fact verification given semi-structured data as evidence. To this end, we construct a large-scale dataset called TabFact with 16k Wikipedia tables as the evidence for $1 1 8 \mathrm { k }$ human-annotated natural language statements, which are labeled as either ENTAILED or REFUTED. TabFact is challenging since it involves both soft linguistic reasoning and hard symbolic reasoning. To address these reasoning challenges, we design two different models: Table-BERT and Latent Program Algorithm (LPA). Table-BERT leverages the state-of-the-art pre-trained language model to encode the linearized tables and statements into continuous vectors for verification. LPA parses statements into programs and executes them against the tables to obtain the returned binary value for verification. Both methods achieve similar accuracy but still lag far behind human performance. We also perform a comprehensive analysis to demonstrate great future opportunities. The data and code of the dataset are provided in https://github.com/wenhuchen/Table-Fact-Checking.
+
+# 1 INTRODUCTION
+
+Verifying whether a textual hypothesis is entailed or refuted by the given evidence is a fundamental problem in natural language understanding (Katz & Fodor, 1963; Van Benthem et al., 2008). It can benefit many downstream applications like misinformation detection, fake news detection, etc. Recently, the first-ever end-to-end fact-checking system has been designed and proposed in Hassan et al. (2017). The verification problem has been extensively studied under different natural language tasks such as recognizing textual entailment (RTE) (Dagan et al., 2005), natural language inference (NLI) (Bowman et al., 2015), claim verification (Popat et al., 2017; Hanselowski et al., 2018; Thorne et al., 2018) and multimodal language reasoning (NLVR/NLVR2) (Suhr et al., 2017; 2019). RTE and NLI view a premise sentence as the evidence, claim verification views passage collection like Wikipedia1 as the evidence, NLVR/NLVR2 views images as the evidence. These problems have been previously addressed using a variety of techniques including logic rules, knowledge bases, and neural networks. Recently large-scale pre-trained language models (Devlin et al., 2019; Peters et al., 2018; Yang et al., 2019; Liu et al., 2019) have surged to dominate the other algorithms to approach human performance on several textual entailment tasks (Wang et al., 2018; 2019).
+
+However, existing studies are restricted to dealing with unstructured text as the evidence, which would not generalize to the cases where the evidence has a highly structured format. Since such structured evidence (graphs, tables, or databases) are also ubiquitous in real-world applications like database systems, dialog systems, commercial management systems, social networks, etc, we argue that the fact verification under structured evidence forms is an equivalently important yet underexplored problem. Therefore, in this paper, we are specifically interested in studying fact verification with semi-structured Wikipedia tables (Bhagavatula et al., 2013)2 as evidence owing to its structured and ubiquitous nature (Jauhar et al., 2016; Zhong et al., 2017; Pasupat & Liang, 2015). To this end, we introduce a large-scale dataset called TABFACT, which consists of 118K manually annotated statements with regard to 16K Wikipedia tables, their relations are classified as ENTAILED and REFUTED3. The entailed and refuted statements are both annotated by human workers. With some examples in Figure 1, we can clearly observe that unlike the previous verification related problems, TABFACT combines two different forms of reasoning in the statements, (i) Linguistic Reasoning: the verification requires semantic-level understanding. For example, “John J. Mcfall failed to be re-elected though being unopposed.” requires understanding over the phrase “lost renomination ...” in the table to correctly classify the entailment relation. Unlike the existing QA datasets (Zhong et al., 2017; Pasupat & Liang, 2015), where the linguistic reasoning is dominated by paraphrasing, TABFACT requires more linguistic inference or common sense. (ii) Symbolic Reasoning: the verification requires symbolic execution on the table structure. For example, the phrase “There are three Democrats incumbents” requires both condition operation (where condition) and arithmetic operation (count). Unlike question answering, a statement could contain compound facts, all of these facts need to be verified to predict the verdict. For example, the ”There are ...” in Figure 1 requires verifying three QA pairs (total coun $\scriptstyle { \mathrm { t } } = 5$ , democratic coun ${ \boldsymbol { \cdot } } = 2$ , republic coun $^ { - 3 }$ ). The two forms of reasoning are interleaved across the statements making it challenging for existing models.
+
+United States House of Representatives Elections, 1972   
+
+<table><tr><td>District</td><td>Incumbent</td><td>Party</td><td>Result</td><td colspan="2"></td><td>Candidates</td></tr><tr><td>California 3</td><td>JohnE.Moss</td><td>democratic</td><td>re-elected</td><td colspan="2"></td><td>John E.Moss (d) 69.9% John Rakus (r)30.1%</td></tr><tr><td>California 5</td><td>Phillip Burton</td><td>democratic</td><td>re-elected</td><td colspan="2"></td><td>Phillip Burton (d) 81.8% Edlo E.Powell(r)18.2%</td></tr><tr><td>California 8</td><td>George Paul Miller</td><td>democratic</td><td></td><td colspan="2">lost renomination democratic hold</td><td>Pete Stark (d) 52.9% Lew M.Warden,Jr. (r)47.1%</td></tr><tr><td colspan="2">California 14</td><td>Jerome R.Waldie</td><td>republican</td><td colspan="2">re-elected</td><td>Jerome R.Waldie (d) 77.6%Floyd E.Sims (r) 22.4%</td></tr><tr><td colspan="2">California 15</td><td>John J. Mcfall</td><td>republican</td><td colspan="2">re-elected</td><td>John J.Mcfal (d) unopposed</td></tr><tr><td colspan="5">Entailed Statement</td><td colspan="2">Refuted Statement</td></tr><tr><td colspan="5">John E.Moss and Phillip Burton are both re-elected in the 1. house of representative election. John J. Mcfallis unopposed during the re-election.</td><td colspan="2">1. John E.Moss and George Paul Miller are both re-electedin the house of representative election.</td></tr><tr><td colspan="5">2. 3.</td><td colspan="2">2. John J. Mcfallfailed to be re-elected though being unopposed.</td></tr><tr><td colspan="5">There are three different incumbents from democratic.</td><td colspan="2">3. There are five candidates in total, two of them are democrats and three of them are republicans.</td></tr></table>
+
+In this paper, we particularly propose two approaches to deal with such mixed-reasoning challenge: (i) Table-BERT, this model views the verification task completely as an NLI problem by linearizing a table as a premise sentence $p$ , and applies state-of-the-art language understanding pre-trained model to encode both the table and statements $h$ into distributed representation for classification. This model excels at linguistic reasoning like paraphrasing and inference but lacks symbolic reasoning skills. (ii) Latent Program Algorithm, this model applies lexical matching to find linked entities and triggers to filter pre-defined APIs (e.g. argmax, argmin, count, etc). We adopt bread-first-search with memorization to construct the potential program candidates, a discriminator is further utilized to select the most “consistent” latent programs. This model excels at the symbolic reasoning aspects by executing database queries, which also provides better interpretability by laying out the decision rationale. We perform extensive experiments to investigate their performances: the best-achieved accuracy of both models are reasonable, but far below human performance. Thus, we believe that the proposed table-based fact verification task can serve as an important new benchmark towards the goal of building powerful AI that can reason over both soft linguistic form and hard symbolic forms. To facilitate future research, we released all the data, code with the intermediate results.
+
+# 2 TABLE FACT VERIFICATION DATASET
+
+First, we follow the previous Table-based Q&A datasets (Pasupat & Liang, 2015; Zhong et al., 2017) to extract web tables (Bhagavatula et al., 2013) with captions from WikiTables4. Here we filter out overly complicated and huge tables (e.g. multirows, multicolumns, latex symbol) and obtain 18K relatively clean tables with less than 50 rows and 10 columns.
+
+For crowd-sourcing jobs, we follow the human subject research protocols5 to pay Amazon Mechanical Turk6 workers from the native English-speaking countries “US, GB, NZ, CA, AU” with approval rates higher than $9 5 \%$ and more than 500 accepted HITs. Following WikiTableQuestion (Pasupat & Liang, 2015), we provide the annotators with the corresponding table captions to help them better understand the background. To ensure the annotation quality, we develop a pipeline of “positive two-channel annotation” “negative statement rewriting” “verification”, as described below.
+
+2.1 POSITIVE TWO-CHANNEL COLLECTION & NEGATIVE REWRITING STRATEGY
+
+To harvest statements of different difficulty levels, we design a two-channel collection process:
+
+Low-Reward Simple Channel: the workers are paid 0.45 USD for annotating one Human Intelligent Task (HIT) that requires writing five statements. The workers are encouraged to produce plain statements meeting the requirements: (i) corresponding to a single row/record in the table with unary fact without involving compound logical inference. (ii) mention the cell values without dramatic modification or paraphrasing. The average annotation time of a HIT is $4 . 2 \mathrm { m i n }$ .
+
+High-Reward Complex Channel: the workers are paid 0.75 USD for annotating a HIT (five statements). They are guided to produce more sophisticated statements to meet the requirements: (i) involving multiple rows in the tables with higher-order semantics like argmax, argmin, count, difference, average, summarize, etc. (ii) rephrase the table records to involve more semantic understanding. The average annotation time of a HIT is $6 . 8 \mathrm { { m i n } }$ . The data obtained from the complex channel are harder in terms of both linguistic and symbolic reasoning, the goal of the two-channel split is to help us understand the proposed models can reach under different levels of difficulty.
+
+As suggested in (Zellers et al., 2018), there might be annotation artifacts and conditional stylistic patterns such as length and word-preference biases, which can allow shallow models (e.g. bag-ofwords) to obtain artificially high performance. Therefore, we design a negative rewriting strategy to minimize such linguistic cues or patterns. Instead of letting the annotators write negative statements from scratch, we let them rewrite the collected entailed statements. During the annotation, the workers are explicitly guided to modify the words, phrases or sentence structures but retain the sentence style/length to prevent artificial cues. We disallow naive negations by adding “not, never, etc” to revert the statement polarity in case of obvious linguistic patterns.
+
+# 2.2 QUALITY CONTROL
+
+To control the quality of the annotation process, we review a randomly sampled statement from each HIT to decide whether the whole annotation job should be rejected during the annotation process. Specifically, a HIT must satisfy the following criteria to be accepted: (i) the statements should contain neither typos nor grammatical errors. (ii) the statements do not contain vague claims like might, few, etc. (iii) the claims should be explicitly supported or contradicted by the table without requiring the additional knowledge, no middle ground is permitted. After the data collection, we re-distribute all the annotated samples to further filter erroneous statements, the workers are paid 0.05 USD per statement to decide whether the statement should be rejected. The criteria we apply are similar: no ambiguity, no typos, explicitly supported or contradictory. Through the post-filtering process, roughly $18 \%$ entailed and $27 \%$ refuted instances are further abandoned due to poor quality.
+
+![](images/85ad40328213abc8f4e715fbb7a475f7accddb45ff5934d7eaccf84b73fcd1bf.jpg)  
+Proportion of different Higher-order Operations
+
+Figure 2: Proportion of different higher-order operations from the simple/complex channels.   
+
+<table><tr><td>Channel</td><td>#Sentence</td><td>#Table</td><td>Len(Ent)</td><td>Len(Ref)</td><td>Split</td><td>#Sentence</td><td>Table</td><td>Row</td><td>Col</td></tr><tr><td>Simple</td><td>50,244</td><td>9,189</td><td>13.2</td><td>13.1</td><td>Train</td><td>92,283</td><td>13,182</td><td>14.1</td><td>5.5</td></tr><tr><td>Complex</td><td>68,031</td><td>7,392</td><td>14.2</td><td>14.2</td><td>Val</td><td>12,792</td><td>1,696</td><td>14.0</td><td>5.4</td></tr><tr><td>Total</td><td>118,275</td><td>16,573</td><td>13.8</td><td>13.8</td><td>Test</td><td>12,779</td><td>1,695</td><td>14.2</td><td>5.4</td></tr></table>
+
+Table 1: Basic statistics of the data collected from the simple/complex channel and the division of Train/Val/Test Split in the dataset, where “Len” denotes the averaged sentence length.
+
+# 2.3 DATASET STATISTICS
+
+Inter-Annotator Agreement: After the data collection pipeline, we merged the instances from two different channels to obtain a diverse yet clean dataset for table-based fact verification. We sample 1000 annotated (table, statement) pairs and re-distribute each to 5 individual workers to re-label them as either ENTAILED or REFUTED. We follow the previous works (Thorne et al., 2018; Bowman et al., 2015) to adopt the Fleiss Kappa (Fleiss, 1971) as an indicator, where Fleiss $\begin{array} { r } { \kappa = { \frac { \bar { p _ { c } } - \bar { p _ { e } } } { 1 - \bar { p _ { e } } } } } \end{array}$ p¯c−p¯e is computed from from the observed agreement $\bar { p _ { c } }$ and the agreement by chance $\bar { p _ { e } }$ . We obtain a Fleiss $\kappa = 0 . 7 5$ , which indicates strong inter-annotator agreement and good-quality.
+
+Dataset Statistics: As shown in Table 1, the amount of data harvested via the complex channel slightly outnumbers the simple channel, the averaged length of both the positive and negative samples are indistinguishable. More specifically, to analyze to which extent the higher-order operations are included in two channels, we group the common higher-order operations into 8 different categories. As shown in Figure 2, we sample 200 sentences from two different channels to visualize their distribution. We can see that the complex channel overwhelms the simple channel in terms of the higher-order logic, among which, count and superlatives are the most frequent. We split the whole data roughly with 8:1:1 into train, validation7, and test splits and shows their statistics in Table 1. Each table with an average of 14 rows and 5-6 columns corresponds to 2-20 different statements, while each cell has an average of 2.1 words. In the training split, the positive instances slightly outnumber the negative instances, while the validation and test split both have rather balanced distributions over positive and negative instances.
+
+# 3 MODELS
+
+With the collected dataset, we now formally define the table-based fact verification task: the dataset is comprised of triple instances $( \mathbf { T } , S , L )$ consisting of a table $\mathbf { T }$ , a natural language statement $S = s _ { 1 } , \cdots , s _ { n }$ and a verification label $\dot { L } \in \{ 0 , 1 \}$ . The table $\mathbf { T } = \{ T _ { i , j } | i \leq \bar { R _ { T } } , \bar { j } \leq C _ { T } \}$ has $R _ { T }$ rows and $C _ { T }$ columns with the $T _ { i j }$ being the content in the $( i , j )$ -th cell. $T _ { i j }$ could be a word, a number, a phrase, or even a natural language sentence. The statement S describes a fact to be verified against the content in the table $\mathbf { T }$ . If it is entailed by $\mathbf { T }$ , then $L = 1$ , otherwise the label $L = 0$ . Figure 1 shows some entailed and refuted examples. During training, the model and the learning algorithm are presented with $K$ instances like $( \boldsymbol { \hat { \mathbf { T } } } , \boldsymbol { S } , \boldsymbol { L } ) _ { k = 1 } ^ { K }$ from the training split. In the testing stage, the model is presented with $( \mathbf { T } , S ) _ { k = 1 } ^ { K ^ { \prime } }$ and supposed to predict the label as $\hat { L }$ . We measure the performance by the prediction accuracy $\begin{array} { r } { A c c = \frac { 1 } { K ^ { \prime } } \sum _ { 1 } ^ { K ^ { \prime } } \mathbb { I } ( \hat { L } _ { k } = L _ { k } ) } \end{array}$ on the test set. Before building the model, we first perform entity linking to detect all the entities in the statements. Briefly, we first lemmatize the words and search for the longest sub-string matching pairs between statements and table cells/captions, where the matched phrases are denoted as the linked entities. To focus on statement verification against the table, we do not feed the caption to the model and simply mask the phrases in the statements which link to the caption with placeholders. The details of the entity linker are listed in the Appendix. We describe our two proposed models as follows.
+
+# 3.1 LATENT PROGRAM ALGORITHM (LPA)
+
+In this approach, we formulate the table fact verification as a program synthesis problem, where the latent program algorithm is not given in TABFACT. Thus, it can be seen as a weakly supervised learning problem as discussed in Liang et al. (2017); Lao et al. (2011). Under such a setting, we propose to break down the verification into two stages: (i) latent program search, (ii) discriminator ranking. In the first program synthesis step, we aim to parse the statement into programs to represent its semantics. We define the plausible API set to include roughly 50 different functions like min, max, count, average, filter, and and realize their interpreter with Python-Pandas. Each API is defined to take arguments of specific types (number, string, bool, and view (e.g sub-table)) to output specifictype variables. During the program execution, we store the generated intermediate variables to different-typed caches $\mathcal { N } , \mathcal { R } , B , \mathcal { V }$ (Num, Str, Bool, View). At each execution step, the program can fetch the intermediate variable from the caches to achieve semantic compositionality. In order to shrink the search space, we follow NSM (Liang et al., 2017) to use trigger words to prune the API set and accelerate the search speed. The definitions of all API, trigger words can be found in the Appendix. The comprehensive the latent program search procedure is summarized in Algorithm 1, and the searching procedure is illustrated in Figure 3.
+
+Algorithm 1 Latent Program Search with Comments   
+
+<table><tr><td rowspan=1 colspan=1>20:</td></tr><tr><td rowspan=1 colspan=1>21:</td></tr></table>
+
+After we collected all the potential program candidates $\mathcal { P } = \{ ( P _ { 1 } , A _ { 1 } ) , \cdots , ( P _ { n } , A _ { n } ) \}$ for a given statement $S$ (where $( P _ { i } , A _ { i } )$ refers to $i$ -th candidate), we need to learn a discriminator to identify the “appropriate” traces from the set from many erroneous and spurious traces. Since we do not have the ground truth label about such discriminator, we use a weakly supervised training algorithm by viewing all the label-consistent programs as positive instances $\{ \bar { P _ { i } } | ( P _ { i } , A _ { i } ) ; A _ { i } \stackrel { . } { = } L \}$ and the label-inconsistent program as negative instances $\{ P _ { i } | ( P _ { i } , A _ { i } ) ; A _ { i } \ \stackrel { . } { \neq } \ \dot { L } \}$ to minimize the cross-entropy of discriminator $p _ { \theta } ( S , P )$ with the weakly supervised label. Specifically, we build our discriminator with a Transformer-based two-way encoder (Vaswani et al., 2017), where the statement encoder encodes the input statement $S$ as a vector $E n c ^ { S } ( S ) \ \in \ \mathbb { R } ^ { n \times D }$ with dimension $D$ , while the program encoder encodes the program $P ~ = ~ p _ { 1 } , \cdot \cdot \cdot , p _ { m }$ as another vector $E n c ^ { P } ( { \cal P } ) \in \mathbb { R } ^ { m \times \hat { D } }$ , we concatenate these two vectors and feed it into a linear projection layer to compute $p _ { \theta } ( S , P ) = \sigma ( v _ { p } ^ { T } [ E n c ^ { S } ( S ) ; E n c ^ { P } ( P ) ] )$ as the relevance between S and $P$ with weight $v _ { p } \in \mathbb { R } ^ { D }$ . At test time, we use the discriminator $p _ { \theta }$ to assign confidence $p _ { \theta } ( S , P )$ to each candidate $\bar { P } \in \mathcal { P }$ , and then either aggregate the prediction from all hypothesis with the confidence weights or rank the highest-confident hypothesis and use their outputs as the prediction.
+
+![](images/37f019384ab116dfeec8bf1b54970e74ed72f73a72a5068f41f633a93167bff4.jpg)  
+Figure 3: The program synthesis procedure for the table in Figure 1. We link the entity (e.g. democratic, republican), and then composite functions on the fly to return the values from the table.
+
+![](images/92f12be640234412878dcc76845c6c58f8c2cb9f87582f83b20a8cea0c2c0b32.jpg)  
+Figure 4: The diagram of Table-BERT with horizontal scan, two different linearizations are depicted.
+
+# 3.2 TABLE-BERT
+
+In this approach, we view the table verification problem as a two-sequence binary classification problem like NLI or MPRC (Wang et al., 2018) by linearizing a table $\mathbf { T }$ into a sequence and treating the statement as another sequence. Since the linearized table can be extremely long surpassing the limit of sequence models like LSTM, Transformers, etc. We propose to shrink the sequence by only retaining the columns containing entities linked to the statement to alleviate such a memory issue. In order to encode such sub-table as a sequence, we propose two different linearization methods, as is depicted in Figure 4. (i) Concatenation: we simply concatenate the table cells with [SEP] tokens in between and restart position counter at the cell boundaries; the column name is fed as another type embedding to the input layer. Such design retains the table information in its machine format. (ii) Template: we adopt simple natural language templates to transform a table into a “somewhat natural” sentence. Taking the horizontal scan as an example, we linearize a table as “row one’s game is 51; the date is February; ..., the score is 3.4 (ot). row 2 is ...”. The isolated cells are connected with punctuations and copula verbs in a language-like format.
+
+After obtaining the linearized sub-table $\tilde { \mathbf { T } }$ , we concatenate it with the natural language statement S and prefix a [CLS] token to the sentence to obtain the sequence-level representation ${ \cal H } = f _ { B E R T } ( [ { \bf \tilde { T } } , S ] )$ , with $H \in \mathbb { R } ^ { 7 6 8 }$ from pre-trained BERT (Devlin et al., 2019). The representation is further fed into multi-layer perceptron $f _ { M L P }$ to obtain the entailment probability $p _ { \theta } ( \tilde { \mathbf { T } } , S ) = \sigma ( f _ { M L P } ( H ) )$ , where $\sigma$ is the sigmoid function. We finetune the model $\theta$ (including the parameters of BERT and MLP) to minimize the binary cross entropy $\mathcal { L } ( p _ { \theta } ( \mathbf { \tilde { T } } , S ) , L )$ on the training set. At test time, we use the trained BERT model to compute the matching probability between the (table, statement) pair, and classify it as ENTAILED statement when $p _ { \theta } ( \tilde { \mathbf { T } } , S )$ is greater than 0.5.
+
+# 4 EXPERIMENTS
+
+In this section, we aim to evaluate the proposed methods on TABFACT. Besides the standard validation and test sets, we also split the test set into a simple and a complex partition based on the channel from which they were collected. This facilitates analyzing how well the model performs under different levels of difficulty. Additionally, we also hold out a small test set with 2K samples for human evaluation, where we distribute each (table, statement) pair to 5 different workers to approximate human judgments based on their majority voting, the results are reported in Table 2.
+
+<table><tr><td>Model</td><td>Val</td><td>Test</td><td>Test (simple)</td><td>Test (complex)</td><td>Small Test</td></tr><tr><td>BERTclassifier w/o Table</td><td>50.9</td><td>50.5</td><td>51.0</td><td>50.1</td><td>50.4</td></tr><tr><td>Table-BERT-Horizontal-F+T-Concatenate</td><td>50.7</td><td>50.4</td><td>50.8</td><td>50.0</td><td>50.3</td></tr><tr><td>Table-BERT-Vertical-F+T-Template</td><td>56.7</td><td>56.2</td><td>59.8</td><td>55.0</td><td>56.2</td></tr><tr><td>Table-BERT-Vertical-T+F-Template</td><td>56.7</td><td>57.0</td><td>60.6</td><td>54.3</td><td>55.5</td></tr><tr><td>Table-BERT-Horizontal-F+T-Template</td><td>66.0</td><td>65.1</td><td>79.0</td><td>58.1</td><td>67.9</td></tr><tr><td>Table-BERT-Horizontal-T+F-Template</td><td>66.1</td><td>65.1</td><td>79.1</td><td>58.2</td><td>68.1</td></tr><tr><td>NSM w/RL (Binary Reward)</td><td>54.1</td><td>54.1</td><td>55.4</td><td>53.1</td><td>55.8</td></tr><tr><td>NSM w/LPA-guided ML + RL</td><td>63.2</td><td>63.5</td><td>77.4</td><td>56.1</td><td>66.9</td></tr><tr><td>LPA-Voting w/o Discriminator</td><td>57.7</td><td>58.2</td><td>68.5</td><td>53.2</td><td>61.5</td></tr><tr><td>LPA-Weighted-Voting</td><td>62.5</td><td>63.1</td><td>74.6</td><td>57.3</td><td>66.8</td></tr><tr><td>LPA-Ranking w/Discriminator</td><td>65.2</td><td>65.0</td><td>78.4</td><td>58.5</td><td>68.6</td></tr><tr><td>LPA-Ranking w/ Discriminator (Caption)</td><td>65.1</td><td>65.3</td><td>78.7</td><td>58.5</td><td>68.9</td></tr><tr><td>Human Performance</td><td>-</td><td>-</td><td>1</td><td>-</td><td>92.1</td></tr></table>
+
+Table 2: The results of different models, the numbers are in percentage. $\mathrm { T } { \mathrm { + F } }$ means table followed by fact, while $\mathrm { F } { + } \mathrm { T }$ means fact followed by table. NSM is modified from Liang et al. (2017).
+
+NSM We follow Liang et al. (2017) to modify their approach to fit the setting of TABFACT. Specifically, we adopt an LSTM as an encoder and another LSTM with copy mechanism as a decoder to synthesize the program. However, without any ground truth annotation for the intermediate programs, directly training with reinforcement learning is difficult as the binary reward is underspecified, which is listed in Table 2 as ”NSM w/ RL”. Further, we use LPA as a teacher to search the top programs for the NSM to bootstrap and then use reinforcement learning to finetune the model, which achieves reasonable performance on our dataset listed as ”NSM w/ $\mathbf { M L } + \mathbf { R L } ^ { \prime }$ .
+
+Table-BERT We build Table-BERT based on the open-source implementation of BERT8 using the pre-trained model with 12-layer, 768-hidden, 12-heads, and 110M parameters trained in 104 languages. We use the standard BERT tokenizer to break the words in both statements and tables into subwords and join the two sequences with a [SEP] token in between. The representation corresponding to [CLS] is fed into an MLP layer to predict the verification label. We finetune the model on a single TITAN X GPU with a mini-batch size of 6. The best performance is reached after about 3 hours of training (around 10K steps). We implement and compare the following variants of the Table-BERT model including (i) Concatenation vs. Template: whether to use natural language templates during linearization. (ii) Horizontal vs. Vertical: scan direction in linearization.
+
+LPA We run the latent program search in a distributed fashion on three 64-core machines to generate the latent programs. The search terminates once the buffer has more than 50 traces or the path length is larger than 7. The average search time for each statement is about 2.5s. For the discriminator model, we design two transformer-based encoders (3 layers, 128-dimension hidden embedding, and 4 heads at each layer) to encode the programs and statements, respectively. The variants of LPA models considered include (i) Voting: assign each program with equal weight and vote without the learned discriminator. (ii) Weighted-Voting: compute a weighted-sum to aggregate the predictions of all latent programs with the discriminator confidence as the weights. (iii) Ranking: rank all the hypotheses by the discriminator confidence and use the top-rated hypothesis as the output. (Caption) means feeding the caption as a sequence of words to the discriminator during ranking.
+
+Preliminary Evaluation In order to test whether our negative rewriting strategy eliminates the artifacts or shallow cues, we also fine-tune a pre-trained BERT (Devlin et al., 2019) to classify the statement $S$ without feeding in table information. The result is reported as “BERT classifier w/o
+
+Table” in Table 2, which is approximately the majority guess and reflects the effectiveness of the rewriting strategy. Before presenting the experiment results, we first perform a preliminary study to evaluate how well the entity linking system, program search, and the statement-program discriminator perform. Since we do not have the ground truth labels for these models, we randomly sample 100 samples from the dev set to perform the human study. For the entity linking, we evaluate its accuracy as the number of correctly linked sentences / total sentences. For the latent program search, we evaluate whether the “true” programs are included in the candidate set $\mathcal { P }$ as recall score.
+
+Results We report the performance of different methods as well as human performance in Table 2. First of all, we observe that the naive serialized model fails to learn anything effective (same as the Majority Guess). It reveals the importance of template when using the pre-trained BERT (Devlin et al., 2019) model: the “natural” connection words between individual cells is able to unleash the power of the large pre-trained language model and enable it to perform reasoning on the structured table form. Such behavior is understandable given the fact that BERT is pre-trained on purely natural language corpora. In addition, we also observe that the horizontal scan excels in the vertical scan because it better captures the convention of human expression. Among different LPA methods, we found that LPA-Ranking performs the best since it can better suppress the spurious programs than the voting-based algorithm. Overall, the LPA model is on par with Table-BERT on both simple and test split without any pre-training on external corpus, which reflects the effectiveness of LPA to leverage symbolic operations in the verification process.
+
+Through our human evaluation, we found that only $58 \%$ of sentences have been correctly linked without missing-link or over-link, while the systematic search has a recall of $51 \%$ under the cases where the sentence is correctly linked. With that being said, the chance for LPA method to cover the correct program (rationale) is roughly under $30 \%$ . After the discriminator’s re-ranking step, the probability of selecting these particular oracle program is even much lower. However, we still observe a final overall accuracy of $65 \%$ , which indicates that the spurious problem is quite severe in LPA, where the correct label is predicted based on the wrong reason.
+
+Through our human evaluation, we also observe that Table-BERT exhibits poor consistency as it can misclassify simple cases but correctly-classify hard cases. These two major weaknesses are yet to be solved in future studies. In contrast, LPA behaves much more consistently and provides a clear latent rationale for its decision. But, such a pipeline system requires laborious handcrafting of API operations and is also very sensitive to the entity linking accuracy. Both methods have pros and cons; how to combine them still remains an open question.
+
+Program Annotation To further promote the development of different models in our dataset, we collect roughly 1400 human-annotated programs paired with the original statements. These statements include the most popular logical operations like superlative, counting, comparison, unique, etc. We provide these annotations in Github9, which can either be used to bootstrap the semantic parsers or provide the rationale for NLI models.
+
+# 5 RELATED WORK
+
+Natural Language Inference & Reasoning: Modeling reasoning and inference in human language is a fundamental and challenging problem towards true natural language understanding. There has been extensive research on RTE in the early years (Dagan et al., 2005) and more recently shifted to NLI (Bowman et al., 2015; Williams et al., 2017). NLI seeks to determine whether a natural language hypothesis $h$ can be inferred from a natural language premise $p$ . With the surge of deep learning, there have been many powerful algorithms like the Decomposed Model (Parikh et al., 2016), Enhanced-LSTM (Chen et al., 2017) and BERT (Devlin et al., 2019). Besides the textual evidence, NLVR (Suhr et al., 2017) and NLVR2 (Suhr et al., 2019) have been proposed to use images as the evidence for statement verification on multi-modal setting. Our proposed fact verification task is closely related to these inference tasks, where our semi-structured table can be seen as a collection of “premises” exhibited in a semi-structured format. Our proposed problem hence could be viewed as the generalization of NLI under the semi-structured domain.
+
+Table Question Answering: Another line of research closely related to our task is the table-based question answering, such as MCQ (Jauhar et al., 2016), WikiTableQuestion (Pasupat & Liang, 2015), Spider (Yu et al., 2018), Sequential Q&A (Iyyer et al., 2017), and WikiSQL (Zhong et al., 2017), for which approaches have been extended to handle large-scale tables from Wikipedia (Bhagavatula et al., 2013). However, in these Q&A tasks, the question types typically provide strong signals needed for identifying the type of answers, while TABFACT does not provide such specificity. The uniqueness of TABFACT lies in two folds: 1) a given fact is regarded as a false claim as long as any part of the statement contains misinformation. Due to the conjunctive nature of verification, a fact needs to be broken down into several sub-clauses or (Q, A) pairs to separate evaluate their correctness. Such a compositional nature of the verification problem makes it more challenging than a standard QA setting. On one hand, the model needs to recognize the multiple QA pairs and their relationship. On the other hand, the multiple sub-clauses make the semantic form longer and logic inference harder than the standard QA setting. 2) some facts cannot even be handled using semantic forms, as they are driven by linguistic inference or common sense. In order to verify these statements, more inference techniques have to be leveraged to enable robust verification. We visualize the above two characteristics of TABFACT in Figure 5.
+
+![](images/84b555a1c00412ee22dcd1ade812c4f361e58ae1670a6e4d81198e9863daf7a4.jpg)  
+Figure 5: The two uniqueness of Table-based fact verification against standard QA problems.
+
+Program Synthesis & Semantic Parsing: There have also been great interests in using program synthesis or logic forms to solve different natural language processing problems like question answering (Liang et al., 2013; Berant et al., 2013; Berant & Liang, 2014), visual navigation (Artzi et al., 2014; Artzi & Zettlemoyer, 2013), code generation (Yin & Neubig, 2017; Dong & Lapata, 2016), SQL synthesis (Yu et al., 2018), etc. The traditional semantic parsing papers (Artzi et al., 2014; Artzi & Zettlemoyer, 2013; Zettlemoyer & Collins, 2005; Liang et al., 2013; Berant et al., 2013) greatly rely on rules, lexicon to parse natural language sentences into different forms like lambda calculus, DCS, etc. More recently, researchers strive to propose neural models to directly perform end-to-end formal reasoning like Theory Prover (Riedel et al., 2017; Rocktaschel & Riedel, ¨ 2017), Neural Turing Machine (Graves et al., 2014), Neural Programmer (Neelakantan et al., 2016; 2017) and Neural-Symbolic Machines (Liang et al., 2017; 2018; Agarwal et al., 2019). The proposed TABFACT serves as a great benchmark to evaluate the reasoning ability of different neural reasoning models. Specifically, TABFACT poses the following challenges: 1) spurious programs (i.e., wrong programs with the true returned answers): since the program output is only a binary label, which can cause serious spurious problems and misguide the reinforcement learning with the under-specified binary rewards. 2) decomposition: the model needs to decompose the statement into sub-clauses and verify the sub-clauses one by one, which normally requires the longer logic inference chains to infer the statement verdict. 3) linguistic reasoning like inference and paraphrasing.
+
+Fact Checking The problem of verifying claims and hypotheses on the web has drawn significant attention recently due to its high social influence. Different fact-checking pioneering studies have been performed including LIAR (Wang, 2017), PolitiFact (Vlachos & Riedel, 2014), FEVER (Thorne et al., 2018) and AggChecker (Jo et al., 2019), etc. The former three studies are mainly based on textual evidence on social media or Wikipedia, while AggChecker is closest to ours in using relational databases as the evidence. Compared to AggChecker, our paper proposes a much larger dataset to benchmark the progress in this direction.
+
+# 6 CONCLUSION
+
+This paper investigates a very important yet previously under-explored research problem: semistructured fact verification. We construct a large-scale dataset and proposed two methods, TableBERT and LPA, based on the state-of-the-art pre-trained natural language inference model and program synthesis. In the future, we plan to push forward this research direction by inspiring more sophisticated architectures that can perform both linguistic and symbolic reasoning.
+
+# REFERENCES
+
+Rishabh Agarwal, Chen Liang, Dale Schuurmans, and Mohammad Norouzi. Learning to generalize from sparse and underspecified rewards. International Conference of Machine Learning, 2019.
+
+Yoav Artzi and Luke Zettlemoyer. Weakly supervised learning of semantic parsers for mapping instructions to actions. Transactions of the Association for Computational Linguistics, 1:49–62, 2013.
+
+Yoav Artzi, Dipanjan Das, and Slav Petrov. Learning compact lexicons for ccg semantic parsing. In Proceedings of the 2014 Conference on Empirical Methods in Natural Language Processing (EMNLP), pp. 1273–1283, 2014.
+
+Jonathan Berant and Percy Liang. Semantic parsing via paraphrasing. In Proceedings of the 52nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 1415–1425, 2014.
+
+Jonathan Berant, Andrew Chou, Roy Frostig, and Percy Liang. Semantic parsing on freebase from question-answer pairs. In Proceedings of the 2013 Conference on Empirical Methods in Natural Language Processing, pp. 1533–1544, 2013.
+
+Chandra Sekhar Bhagavatula, Thanapon Noraset, and Doug Downey. Methods for exploring and mining tables on wikipedia. In Proceedings of the ACM SIGKDD Workshop on Interactive Data Exploration and Analytics, pp. 18–26. ACM, 2013.
+
+Samuel R Bowman, Gabor Angeli, Christopher Potts, and Christopher D Manning. A large annotated corpus for learning natural language inference. In Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing, pp. 632–642, 2015.
+
+Qian Chen, Xiaodan Zhu, Zhen-Hua Ling, Si Wei, Hui Jiang, and Diana Inkpen. Enhanced lstm for natural language inference. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 1657–1668, 2017.
+
+Ido Dagan, Oren Glickman, and Bernardo Magnini. The pascal recognising textual entailment challenge. In Machine Learning Challenges Workshop, pp. 177–190. Springer, 2005.
+
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. Proceedings of NAACL-HLT, 2019.
+
+Li Dong and Mirella Lapata. Language to logical form with neural attention. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 33–43, 2016.
+
+Joseph L Fleiss. Measuring nominal scale agreement among many raters. Psychological bulletin, 76(5):378, 1971.
+
+Alex Graves, Greg Wayne, and Ivo Danihelka. Neural turing machines. arXiv preprint arXiv:1410.5401, 2014.
+
+Andreas Hanselowski, Hao Zhang, Zile Li, Daniil Sorokin, Benjamin Schiller, Claudia Schulz, and Iryna Gurevych. Ukp-athene: Multi-sentence textual entailment for claim verification. arXiv preprint arXiv:1809.01479, 2018.
+
+Naeemul Hassan, Gensheng Zhang, Fatma Arslan, Josue Caraballo, Damian Jimenez, Siddhant Gawsane, Shohedul Hasan, Minumol Joseph, Aaditya Kulkarni, Anil Kumar Nayak, et al. Claimbuster: the first-ever end-to-end fact-checking system. Proceedings of the VLDB Endowment, 10 (12):1945–1948, 2017.
+
+Mohit Iyyer, Wen-tau Yih, and Ming-Wei Chang. Search-based neural structured learning for sequential question answering. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), volume 1, pp. 1821–1831, 2017.
+
+Sujay Kumar Jauhar, Peter Turney, and Eduard Hovy. Tables as semi-structured knowledge for question answering. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), volume 1, pp. 474–483, 2016.
+
+Saehan Jo, Immanuel Trummer, Weicheng Yu, Xuezhi Wang, Cong Yu, Daniel Liu, and Niyati Mehta. Aggchecker: A fact-checking system for text summaries of relational data sets. Proceedings of the VLDB Endowment, 12(12), 2019.
+
+Jerrold J Katz and Jerry A Fodor. The structure of a semantic theory. language, 39(2):170–210, 1963.
+
+Ni Lao, Tom Mitchell, and William W Cohen. Random walk inference and learning in a large scale knowledge base. In Proceedings of the Conference on Empirical Methods in Natural Language Processing, pp. 529–539. Association for Computational Linguistics, 2011.
+
+Chen Liang, Jonathan Berant, Quoc Le, Kenneth D Forbus, and Ni Lao. Neural symbolic machines: Learning semantic parsers on freebase with weak supervision. International Conference of Machine Learning, 2017.
+
+Chen Liang, Mohammad Norouzi, Jonathan Berant, Quoc V Le, and Ni Lao. Memory augmented policy optimization for program synthesis and semantic parsing. In Advances in Neural Information Processing Systems, pp. 9994–10006, 2018.
+
+Percy Liang, Michael I Jordan, and Dan Klein. Learning dependency-based compositional semantics. Computational Linguistics, 39(2):389–446, 2013.
+
+Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. Roberta: A robustly optimized bert pretraining approach. arXiv preprint arXiv:1907.11692, 2019.
+
+Arvind Neelakantan, Quoc V Le, and Ilya Sutskever. Neural programmer: Inducing latent programs with gradient descent. International Conference on Learning Representation, 2016.
+
+Arvind Neelakantan, Quoc V Le, Martin Abadi, Andrew McCallum, and Dario Amodei. Learning a natural language interface with neural programmer. International Conference on Learning Representation, 2017.
+
+Ankur Parikh, Oscar Tackstr ¨ om, Dipanjan Das, and Jakob Uszkoreit. A decomposable attention ¨ model for natural language inference. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, pp. 2249–2255, 2016.
+
+Panupong Pasupat and Percy Liang. Compositional semantic parsing on semi-structured tables. In Proceedings of the 53rd Annual Meeting of the Association for Computational Linguistics and the 7th International Joint Conference on Natural Language Processing (Volume 1: Long Papers), volume 1, pp. 1470–1480, 2015.
+
+Matthew E Peters, Mark Neumann, Mohit Iyyer, Matt Gardner, Christopher Clark, Kenton Lee, and Luke Zettlemoyer. Deep contextualized word representations. In Proceedings of NAACL-HLT, pp. 2227–2237, 2018.
+
+Kashyap Popat, Subhabrata Mukherjee, Jannik Strotgen, and Gerhard Weikum. Where the truth lies: ¨ Explaining the credibility of emerging claims on the web and social media. In Proceedings of the 26th International Conference on World Wide Web Companion, pp. 1003–1012. International World Wide Web Conferences Steering Committee, 2017.
+
+Sebastian Riedel, Matko Bosnjak, and Tim Rocktaschel. Programming with a differentiable forth ¨ interpreter. ICML, 2017.
+
+Tim Rocktaschel and Sebastian Riedel. End-to-end differentiable proving. In ¨ Advances in Neural Information Processing Systems, pp. 3788–3800, 2017.
+
+Alane Suhr, Mike Lewis, James Yeh, and Yoav Artzi. A corpus of natural language for visual reasoning. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 2: Short Papers), pp. 217–223, 2017.
+
+Alane Suhr, Stephanie Zhou, Ally Zhang, Iris Zhang, Huajun Bai, and Yoav Artzi. A corpus for reasoning about natural language grounded in photographs. In Proceedings of the Annual Meeting of the Association for Computational Linguistics, 2019.
+
+James Thorne, Andreas Vlachos, Christos Christodoulopoulos, and Arpit Mittal. Fever: a largescale dataset for fact extraction and verification. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long Papers), volume 1, pp. 809–819, 2018.
+
+Johan Van Benthem et al. A brief history of natural logic. LondonCollege Publications9781904987444, 2008.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in neural information processing systems, pp. 5998–6008, 2017.
+
+Andreas Vlachos and Sebastian Riedel. Fact checking: Task definition and dataset construction. In Proceedings of the ACL 2014 Workshop on Language Technologies and Computational Social Science, pp. 18–22, 2014.
+
+Alex Wang, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R Bowman. Glue: A multi-task benchmark and analysis platform for natural language understanding. EMNLP 2018, pp. 353, 2018.
+
+Alex Wang, Yada Pruksachatkun, Nikita Nangia, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R Bowman. Superglue: A stickier benchmark for general-purpose language understanding systems. arXiv preprint arXiv:1905.00537, 2019.
+
+William Yang Wang. liar, liar pants on fire: A new benchmark dataset for fake news detection. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 2: Short Papers), pp. 422–426, 2017.
+
+Adina Williams, Nikita Nangia, and Samuel R Bowman. A broad-coverage challenge corpus for sentence understanding through inference. arXiv preprint arXiv:1704.05426, 2017.
+
+Zhilin Yang, Zihang Dai, Yiming Yang, Jaime Carbonell, Ruslan Salakhutdinov, and Quoc V Le. Xlnet: Generalized autoregressive pretraining for language understanding. Advances in neural information processing systems, 2019.
+
+Pengcheng Yin and Graham Neubig. A syntactic neural model for general-purpose code generation. arXiv preprint arXiv:1704.01696, 2017.
+
+Tao Yu, Rui Zhang, Kai Yang, Michihiro Yasunaga, Dongxu Wang, Zifan Li, James Ma, Irene Li, Qingning Yao, Shanelle Roman, et al. Spider: A large-scale human-labeled dataset for complex and cross-domain semantic parsing and text-to-sql task. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, pp. 3911–3921, 2018.
+
+Rowan Zellers, Yonatan Bisk, Roy Schwartz, and Yejin Choi. Swag: A large-scale adversarial dataset for grounded commonsense inference. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, pp. 93–104, 2018.
+
+Luke S Zettlemoyer and Michael Collins. Learning to map sentences to logical form: structured classification with probabilistic categorial grammars. In Proceedings of the Twenty-First Conference on Uncertainty in Artificial Intelligence, pp. 658–666. AUAI Press, 2005.
+
+Victor Zhong, Caiming Xiong, and Richard Socher. Seq2sql: Generating structured queries from natural language using reinforcement learning. arXiv preprint arXiv:1709.00103, 2017.
+
+# A APPENDIX
+
+# A.1 FUNCTION DESCRIPTION
+
+We list the detailed function description in Figure 6. We also visualize the functionality of the most
+
+<table><tr><td rowspan=1 colspan=1>Name</td><td rowspan=1 colspan=1>Arguments</td><td rowspan=1 colspan=1>Output</td><td rowspan=1 colspan=1>Comment</td></tr><tr><td rowspan=1 colspan=1>Count</td><td rowspan=1 colspan=1>View</td><td rowspan=1 colspan=1>Number</td><td rowspan=1 colspan=1>Return the number of rows in the View</td></tr><tr><td rowspan=1 colspan=1>within</td><td rowspan=1 colspan=1>View, Header String, CellString/Number</td><td rowspan=1 colspan=1>Bool</td><td rowspan=1 colspan=1>Return whether the cellstring/number exists under the Header Column of the givenview</td></tr><tr><td rowspan=1 colspan=1>Without</td><td rowspan=1 colspan=1>View, Header String, CellString/Number</td><td rowspan=1 colspan=1>Bool</td><td rowspan=1 colspan=1>Return whether the cellstring/number does not exist under the Header Column of thegiven view</td></tr><tr><td rowspan=1 colspan=1>None</td><td rowspan=1 colspan=1>String</td><td rowspan=1 colspan=1>Bool</td><td rowspan=1 colspan=1>Whether the string represents None,like“None&quot;,&quot;No,&quot;-&quot;,&quot;No information provided&quot;</td></tr><tr><td rowspan=1 colspan=1>Before/After</td><td rowspan=1 colspan=1>Row, Row</td><td rowspan=1 colspan=1>Row</td><td rowspan=1 colspan=1>Returns whether rowlis before/after row2</td></tr><tr><td rowspan=1 colspan=1>First/Second/Third/Fourth</td><td rowspan=1 colspan=1>View,Row</td><td rowspan=1 colspan=1>Bool</td><td rowspan=1 colspan=1>Returns whether the row is in the first/second/third position of the view</td></tr><tr><td rowspan=1 colspan=1>Average/Sum/Max/Min</td><td rowspan=1 colspan=1>View, Header String</td><td rowspan=1 colspan=1>Number</td><td rowspan=1 colspan=1>Returns the average/summation/max/min value under the Header Column of the givenview</td></tr><tr><td rowspan=1 colspan=1>Argmin/Argmax</td><td rowspan=1 colspan=1>View, Header String</td><td rowspan=1 colspan=1>Row</td><td rowspan=1 colspan=1>Returns the row with the maximum/minimum value under the Header Column of thegiven view</td></tr><tr><td rowspan=1 colspan=1>Hop</td><td rowspan=1 colspan=1>Row, Header String</td><td rowspan=1 colspan=1>Number/String</td><td rowspan=1 colspan=1>Returns the cell value under the Header Column of the given row</td></tr><tr><td rowspan=1 colspan=1>Diff/Add</td><td rowspan=1 colspan=1>Number, Number</td><td rowspan=1 colspan=1>Number</td><td rowspan=1 colspan=1>Perform arithmetic operations on two numbers</td></tr><tr><td rowspan=1 colspan=1>Greater/Less</td><td rowspan=1 colspan=1>Number, Number</td><td rowspan=1 colspan=1>Bool</td><td rowspan=1 colspan=1>Returns whether the first number is greater/less than the second number</td></tr><tr><td rowspan=1 colspan=1>Equal/Unequal</td><td rowspan=1 colspan=1>String, String/Number, Number</td><td rowspan=1 colspan=1>Bool</td><td rowspan=1 colspan=1>Compare two numbers or strings to see whether they are the same</td></tr><tr><td rowspan=1 colspan=1>Filter_eq/Filter_greater/Filter_less/Filter_greater_or_equal/Filter_less_or_equal</td><td rowspan=1 colspan=1>View, Header String,Number</td><td rowspan=1 colspan=1>View</td><td rowspan=1 colspan=1>Returns the subview of the given with the cellvalues under the Header columngreater/less/eq/..against the given number</td></tr><tr><td rowspan=1 colspan=1>All_eq/All.greater/All_less/AllgreaterorequaI/All_less_or_equal</td><td rowspan=1 colspan=1>View, Header String,Number</td><td rowspan=1 colspan=1>Bool</td><td rowspan=1 colspan=1>Returns the whether all of the cell values under the Header column aregreater/less/eq/.. against the given number</td></tr><tr><td rowspan=1 colspan=1>And/Or</td><td rowspan=1 colspan=1>Bool,Bol</td><td rowspan=1 colspan=1>Bool</td><td rowspan=1 colspan=1>Returns the Boolean operation results of two inputs</td></tr></table>
+
+typical functions and their input/output examples in Figure 7.
+
+![](images/2b9890036ef48d62e436f765e6ed67f1068832ca151aef636e57d8d036cca811.jpg)  
+Figure 6: The function definition used in TabFact.   
+Figure 7: The visualization of different functions.
+
+We list all the trigger words for different functions in Figure 8   
+Figure 8: The trigger words used to shrink the search space.   
+
+<table><tr><td rowspan=1 colspan=1>Trigger</td><td rowspan=1 colspan=1>Function</td></tr><tr><td rowspan=1 colspan=1>&#x27;average&#x27;</td><td rowspan=1 colspan=1>average</td></tr><tr><td rowspan=1 colspan=1>&#x27;difference&#x27;,&#x27;gap&#x27;,&#x27;than&#x27;,&#x27;separate&#x27;</td><td rowspan=1 colspan=1>diff</td></tr><tr><td rowspan=1 colspan=1>&#x27;sum&#x27;,&#x27;summation&#x27;,&#x27;combine&#x27;,&#x27;combined&#x27;,&#x27;total&#x27;,&#x27;add&#x27;,&#x27;all&#x27;,&#x27;thereare&#x27;</td><td rowspan=1 colspan=1>ddd, sum</td></tr><tr><td rowspan=1 colspan=1>&#x27;not&#x27;,&#x27;no&#x27;,&#x27;never&#x27;,&quot;didn&#x27;t&quot;,&quot;won&#x27;t&quot;,&quot;wasn&#x27;t&quot;,&quot;isn&#x27;t,&quot;haven&#x27;t&quot;,&quot;weren&#x27;t&quot;,&quot;won&#x27;t&quot;,&#x27;neither&#x27;,&#x27;none&#x27;,&#x27;unable,&#x27;fail&#x27;,&#x27;different&#x27;,&#x27;outside&#x27;,&#x27;unable&#x27;,&#x27;fail&#x27;</td><td rowspan=1 colspan=1>not_eq, not_within,Filter_not_eq,none</td></tr><tr><td rowspan=1 colspan=1>&#x27;not&#x27;,&#x27;no&#x27;,&#x27;none&#x27;</td><td rowspan=1 colspan=1>none</td></tr><tr><td rowspan=1 colspan=1>&#x27;first&#x27;,&#x27;top&#x27;,&#x27;atest&#x27;,&#x27;most&#x27;</td><td rowspan=1 colspan=1>first</td></tr><tr><td rowspan=1 colspan=1>&quot;last&#x27;,&#x27;bottom&#x27;,&#x27;latest&#x27;,&#x27;most&#x27;</td><td rowspan=1 colspan=1>last</td></tr><tr><td rowspan=1 colspan=1>&#x27;RBR&#x27;,&#x27;JJR&#x27;,&#x27;more&#x27;,&#x27;than&#x27;,&#x27;above&#x27;,&#x27;after&#x27;</td><td rowspan=1 colspan=1>filter_greater, greater</td></tr><tr><td rowspan=1 colspan=1>&#x27;RBR&#x27;,&#x27;JJR&#x27;,&#x27;less&#x27;,&#x27;than&#x27;,&#x27;below&#x27;,&#x27;under&#x27;</td><td rowspan=1 colspan=1>filter_less, less</td></tr><tr><td rowspan=1 colspan=1>&#x27;all&#x27;,&#x27;every&#x27;,&#x27;each&#x27;</td><td rowspan=1 colspan=1>all_eq,all_less,all_greater,</td></tr><tr><td rowspan=1 colspan=1>[&#x27;all&#x27;,&#x27;every&#x27;,&#x27;each&#x27;],[&#x27;not&#x27;,&#x27;no&#x27;,&#x27;never&#x27;,&quot;didn&#x27;t&quot;,&quot;won&#x27;t&quot;,&quot;wasn&#x27;t&quot;]</td><td rowspan=1 colspan=1>all_not_eq</td></tr><tr><td rowspan=1 colspan=1>&#x27;at most&#x27;,&#x27;than&#x27;</td><td rowspan=1 colspan=1>all_less_eq,all_greater_eq</td></tr><tr><td rowspan=1 colspan=1>&#x27;RBR&#x27;,&#x27;RBS&#x27;,&#x27;JJR&#x27;,&#x27;JJS&#x27;</td><td rowspan=1 colspan=1>max, min</td></tr><tr><td rowspan=1 colspan=1>&#x27;JR&#x27;,&#x27;JJS&#x27;,&#x27;RBR&#x27;,&#x27;RBS&#x27;,&#x27;to&#x27;,&#x27;fst</td><td rowspan=1 colspan=1>argmax,argmin</td></tr><tr><td rowspan=1 colspan=1>&#x27;within&#x27;,&#x27;one&#x27;,&#x27;of,&#x27;among&#x27;</td><td rowspan=1 colspan=1>within</td></tr><tr><td rowspan=1 colspan=1>&#x27;follow&#x27;,&#x27;following&#x27;,&#x27;followed&#x27;,&#x27;after&#x27;,&#x27;before&#x27;,&#x27;above&#x27;,&#x27;precede&#x27;</td><td rowspan=1 colspan=1>before</td></tr><tr><td rowspan=1 colspan=1>&#x27;follow&#x27;,&#x27;following&#x27;,&#x27;followed&#x27;,&#x27;after&#x27;,&#x27;before&#x27;,&#x27;above&#x27;,&#x27;precede&#x27;</td><td rowspan=1 colspan=1>after</td></tr><tr><td rowspan=1 colspan=1>&#x27;most&#x27;</td><td rowspan=1 colspan=1>most_freq</td></tr><tr><td rowspan=1 colspan=1>ordinal</td><td rowspan=1 colspan=1>First,second,third,fourth</td></tr></table>
+
+# B HIGHER-ORDER OPERATIONS
+
+1. Aggregation: the aggregation operation refers to sentences like “the averaged age of all ....”, “the total amount of scores obtained in ...”, etc.   
+2. Negation: the negation operation refers to sentences like “xxx did not get the best score”, “xxx has never obtained a score higher than 5”.   
+3. Superlative: the superlative operation refers to sentences like “xxx achieves the highest score in”, “xxx is the lowest player in the team”.   
+4. Comparative: the comparative operation refers to sentences like “xxx has a higher score than yyy”.   
+5. Ordinal: the ordinal operation refers to sentences like “the first country to achieve xxx is xxx”, “xxx is the second oldest person in the country”.   
+6. Unique: the unique operation refers to sentences like “there are 5 different nations in the tournament, ”, “there are no two different players from U.S”   
+7. All: the for all operation refers to sentences like “all of the trains are departing in the morning”, “none of the people are older than 25.”   
+8. None: the sentences which do not involve higher-order operations like “xxx achieves 2 points in xxx game”, “xxx player is from xxx country”.
+
+# C ERROR ANALYSIS
+
+Before we quantitatively demonstrate the error analysis of the two methods, we first theoretically analyze the bottlenecks of the two methods as follows:
+
+Symbolic We first provide a case in which the symbolic execution can not deal with theoretically in Figure 9. The failure cases of symbolic are either due to the entity link problem or function coverage problem. For example, in the given statement below, there is no explicit mention of ”7-5, 6-4” cell. Therefore, the entity linking model fails to link to this cell content. Furthermore, even though we can successfully link to this string, there is no defined function to parse ”7-5, 6-5” as ”won two games” because it requires linguistic/mathematical inference to understand the implication from the string. Such cases are the weakness of symbolic reasoning models.
+
+![](images/3f106b1aa4b5c51cc3639b4f44ed439f435600f8d159aa1666a75ed594195679.jpg)
+
+![](images/40d64137defec9335b2dfb050d1e9dc89c03e9aabae152515b9b2f85a1a3446e.jpg)  
+Figure 9: The error case of symbolic reasoning model
+
+BERT In contrast, Table-BERT model seems to have no coverage problem as long as it can feed the whole table content. However, due to the template linearization, the table is unfolded into a long sequence as depicted in Figure 10. The useful information, ”clay” are separated in a very long span of unrelated words. How to grasp such a long dependency and memorize the history information poses a great challenge to the Table-BERT model.
+
+![](images/7485090f421bd8789ee5f1f327e6529721e2677f8d70fdc2c8b4ba6e89c3f259.jpg)  
+Figure 10: The error case of BERT NLI model
+
+Statistics Here we pick 200 samples from the validation set which only involve single semantic and divide them into different categories. We denote the above-mentioned cases as ”linguistic inference”, and the sentences which only describe information from one row as ”Trivial”, the rest are based on their logic operation like Aggregation, Superlative, Count, etc. We visualize the accuracy of LPA and Table-BERT in Figure 11. From which we can observe that the statements with linguistic inference are much better handled with the BERT model, while LPA achieves an accuracy barely higher than a random guess. The BERT model can deal with trivial cases well as it uses a horizontal scan order. In contrast, the LPA model outperforms BERT on higher-order logic cases, especially when the statement involves operations like Count and Superlative.
+
+![](images/245d9e87e13a0862c0b5d27a3c5b5c9a0d3b6c7d8fde191a1a7272c227e106d7.jpg)  
+Error Analysis of LPA/Table-BERT   
+Figure 11: The error analysis of two different models
+
+# D REASONING DEPTH
+
+Given that our LPA has the breadth to cover a large semantic space. Here we also show the reasoning depth in terms of how many logic inference steps are required to tackle verify the given claims. We visualize the histogram in Figure 12 and observe that the reasoning steps are concentrated between 4 to 7. Such statistics indicate the difficulty of fact verification in our TABFACT dataset.
+
+![](images/825127291fce4bdd67ad4861d2182476f16528f3a53e6052fd99887fcd2bf4be.jpg)  
+Figure 12: The histogram of reasoning steps required to verify the claims
+
+# E WHETHER TO KEEP WIKIPEDIA CONTEXT
+
+Before crowd-sourcing the annotation for the tables, we observed that the previous WikiTableQuestion Pasupat & Liang (2015) provides context (Wikipedia title) during annotation while the WikiSQL Zhong et al. (2017) does not. Therefore, we particularly design ablation annotation tasks to compare the annotation quality between w/ and w/o Wikipedia title as context. We demonstrate a typical example in Figure 13, where a Wiki table10 aims to describe the achievements of a tennis player named Dennis, but itself does not provide any explicit hint about “Tennis Player Dennis”. Unsurprisingly, the sentence fluency and coherence significantly drop without such information. Actually, a great portion of these Wikipedia tables requires background knowledge (like sports, celebrity, music, etc) to understand. We perform a small user study to measure the fluency of annotated statements. Specifically, we collected 50 sentences from both annotation w/ and w/o title context and randomly shuffle them as pairs, which are distributed to the 8 experts without telling them their source to compare the language fluency. It turns out that the experts ubiquitously agree that the statements with Wikipedia titles are more human-readable. Therefore, we argue that such a context is necessary for annotators to understand the background knowledge to write more fluent sentences. On the other end, we also hope to minimize the influence of the textual context in the table-based verification task, therefore, we design an annotation criterion: the Wikipedia title is provided to the workers during the annotation, but they are explicitly banned from bringing any unrelated background information other than the title into the annotation. As illustrated in Figure 13, the title only acts as a placeholder in the statements to make it sound more natural.
+
+![](images/301a78c316e95c017869c01f69e36cbf3cfa0d4be97ddc3c08353e60d268a470.jpg)
+
+# F ENTITY LINKING
+
+Here we propose to use the longest string match to find all the candidate entities in the table, when multiple candidates coexist, we select the one with the minimum edit distances. The visualization is demonstrated in Figure 14.
+
+![](images/a5d843ef5754ca7d5195b4bde57e48ecd0512435de24d714e28c48650edb50fe.jpg)  
+Statement: John E. Moss is a democratic who is from California 3 district
+
+![](images/4ecef75b775904b0569e94f0b9ee6617c45d45e9015b1e0dd502fe9a3787175b.jpg)  
+Figure 14: Entity Linking System.
+
+# G THE PROGRAM CANDIDATES
+
+Here we demonstrate some program candidates in Figure 15, and show how our proposed discriminator is designed to compute the matching probability between the statement and program. Specifically, we employ two transformer-based encoder Vaswani et al. (2017), the left one is aimed to encode the program sequence and the right one is aimed to encode the statement sequence. Their output from [CLS] position is concatenated and fed into an MLP to classify the verification label.
+
+# H HIT INTERFACE
+
+We provide the human intelligent task interface on AMT in the following. Very detailed instructions on what are trivial statements and what are non-trivial statements. Comprehensive examples have been given to guide the Turkers to write well-formed while logically plausible statements. In order to harvest fake statements without statistical cues, we also provide detailed instructions on how to re-write the ”fake” statements. During the annotation, we hire 8 experts to perform sanity checks on each of the HIT to make sure that the annotated dataset is clean and meets our requirements.
+
+Survey Instructions (Click to expand)
+
+You are given a table with its wikipedia source, your job is to compose non-trivial statements supported by the table.
+
+- "Trivial": the sentence can be easily generated by looking only a certain row without understanding the table.
+
+- "Non-trivial": the sentence requires reading multiple rows of the table and understanding of the table content. For example, the sentences which include summarization, comparative, negation, relational, inclusion, superlative, aggregational, rephrase or combinations of them are non-trivial. But non-trvial is not limited to these types, any statement involving understanding and reasoning is accepted.
+
+We list two examples below to help you understand, you are encouraged to open the table wikipedia link to understand the context of the table. (Everything in the table is lower-cased, you are free to use lower or upper case in your sentence):
+
+Table Wikipedia Link: Road_Rules_Challenge:_The_Island (https://en.wikipedia.org/wiki/Real_World/Road_Rules_Challenge:_The_Island)
+
+<table><tr><td rowspan=1 colspan=1>player</td><td rowspan=1 colspan=1> original season</td><td rowspan=1 colspan=1>gender</td><td rowspan=1 colspan=1> eliminated</td><td rowspan=1 colspan=1> placing</td></tr><tr><td rowspan=1 colspan=1>derrick kosinski</td><td rowspan=1 colspan=1>rr : x - treme</td><td rowspan=1 colspan=1>male</td><td rowspan=1 colspan=1>winner</td><td rowspan=1 colspan=1>winner</td></tr><tr><td rowspan=1 colspan=1>evelyn smith</td><td rowspan=1 colspan=1>fresh meat</td><td rowspan=1 colspan=1>female</td><td rowspan=1 colspan=1>winner</td><td rowspan=1 colspan=1>winner</td></tr><tr><td rowspan=1 colspan=1> johnny devenanzio</td><td rowspan=1 colspan=1>rw : key west</td><td rowspan=1 colspan=1>male</td><td rowspan=1 colspan=1>winner</td><td rowspan=1 colspan=1>winner</td></tr><tr><td rowspan=1 colspan=1>kenny santucci</td><td rowspan=1 colspan=1>fresh meat</td><td rowspan=1 colspan=1>male</td><td rowspan=1 colspan=1>winner</td><td rowspan=1 colspan=1>winner</td></tr><tr><td rowspan=1 colspan=1> jenn grijalva</td><td rowspan=1 colspan=1>rw :denver</td><td rowspan=1 colspan=1>female</td><td rowspan=1 colspan=1>episode 8</td><td rowspan=1 colspan=1>runner - up</td></tr><tr><td rowspan=1 colspan=1> paula meronek</td><td rowspan=1 colspan=1>rw : key west</td><td rowspan=1 colspan=1>female</td><td rowspan=1 colspan=1>episode 8</td><td rowspan=1 colspan=1>runner - up</td></tr><tr><td rowspan=1 colspan=1>robin hibbard</td><td rowspan=1 colspan=1>rw : san diego</td><td rowspan=1 colspan=1>female</td><td rowspan=1 colspan=1>episode 8</td><td rowspan=1 colspan=1>runner - up</td></tr><tr><td rowspan=1 colspan=1>ryan kehoe</td><td rowspan=1 colspan=1>fresh meat</td><td rowspan=1 colspan=1>male</td><td rowspan=1 colspan=1>episode 8</td><td rowspan=1 colspan=1>runner - up</td></tr><tr><td rowspan=1 colspan=1>dunbar merrill</td><td rowspan=1 colspan=1>rw : sydney</td><td rowspan=1 colspan=1>male</td><td rowspan=1 colspan=1>episode 8</td><td rowspan=1 colspan=1>9th place</td></tr><tr><td rowspan=1 colspan=1> johanna botta</td><td rowspan=1 colspan=1>rw : austin</td><td rowspan=1 colspan=1>female</td><td rowspan=1 colspan=1>episode 8</td><td rowspan=1 colspan=1>10th place</td></tr><tr><td rowspan=1 colspan=1> kellyanne judd</td><td rowspan=1 colspan=1>rw : sydney</td><td rowspan=1 colspan=1>female</td><td rowspan=1 colspan=1>episode 8</td><td rowspan=1 colspan=1>11th place</td></tr><tr><td rowspan=1 colspan=1>dan walsh</td><td rowspan=1 colspan=1>r : viewers&#x27; revenge</td><td rowspan=1 colspan=1>male</td><td rowspan=1 colspan=1>episode 8</td><td rowspan=1 colspan=1>12th place</td></tr><tr><td rowspan=1 colspan=1>colie edison</td><td rowspan=1 colspan=1>rw :denver</td><td rowspan=1 colspan=1>female</td><td rowspan=1 colspan=1>episode7</td><td rowspan=1 colspan=1>13th place</td></tr><tr><td rowspan=1 colspan=1>cohutta grindstaff</td><td rowspan=1 colspan=1>rw : sydney</td><td rowspan=1 colspan=1>male</td><td rowspan=1 colspan=1>episode 6</td><td rowspan=1 colspan=1>14th place</td></tr><tr><td rowspan=1 colspan=1>tyrie ballard</td><td rowspan=1 colspan=1>rw :denver</td><td rowspan=1 colspan=1>male</td><td rowspan=1 colspan=1>episode 5</td><td rowspan=1 colspan=1>15th place</td></tr><tr><td rowspan=1 colspan=1>ashli robson</td><td rowspan=1 colspan=1>rw : sydney</td><td rowspan=1 colspan=1>female</td><td rowspan=1 colspan=1>episode 4</td><td rowspan=1 colspan=1>16th place</td></tr><tr><td rowspan=1 colspan=1>rachel robinson</td><td rowspan=1 colspan=1>rr : campus crawl</td><td rowspan=1 colspan=1>female</td><td rowspan=1 colspan=1>episode 3</td><td rowspan=1 colspan=1>17th place</td></tr><tr><td rowspan=1 colspan=1>abram boise</td><td rowspan=1 colspan=1>rr : south pacific</td><td rowspan=1 colspan=1>male</td><td rowspan=1 colspan=1>episode 2</td><td rowspan=1 colspan=1>18th place</td></tr><tr><td rowspan=1 colspan=1>dave malinosky</td><td rowspan=1 colspan=1>rw : hollywood</td><td rowspan=1 colspan=1>male</td><td rowspan=1 colspan=1>episode 2 (quit)</td><td rowspan=1 colspan=1>19th place</td></tr></table>
+
+# Rejected ("Trivial") examples:
+
+1. In the TV series "The Island", Derrick Kosinski is a male character. (Easy! You can simply look into first row to produce this sentence.)
+
+2. Derrick Kosinski has the placing of winner in the TV series.
+
+3. Kenny Santucci is from original season of "Fresh Meat".
+
+4. Jenn Grijalva is Runner-Up of the challenge.
+
+# Accepted ("Non-Trivial") examples:
+
+(Superlative): In the TV series "The Island", Evelyn Smith is the highest ranked female.   
+(Comparitive): In the TV series "The Island", Jenn Grijalva appears later than Colie Edison in the series.   
+(Relational): Ashli Robson appears one episode later than Rachel Robinson in the TV series.   
+(Summarization): there are three male winners in the challenge.   
+(Rephrase): Evelyn Smith never eliminated in any episode in the TV series.   
+(Combination): Derrick Kosinski is the winner and Jenn Grijalva is Runner-Up of the challenge.   
+(Negation): jenn grijalva is not the female winning the challenge.   
+(Inclusion): Evelyn smith is one of the four winner for the challenge.
+
+Table Wikipedia Link: AFC_Champions_League (https://en.wikipedia.org/wiki/AFC_Champions_League)
+
+<table><tr><td rowspan=1 colspan=1>rank</td><td rowspan=1 colspan=1>member association</td><td rowspan=1 colspan=1> points</td><td rowspan=1 colspan=1> group stage</td><td rowspan=1 colspan=1> play - off</td><td rowspan=1 colspan=1> afc cup</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>saudi arabia</td><td rowspan=1 colspan=1>860.5</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td></tr><tr><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>qatar</td><td rowspan=1 colspan=1>838.2</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td></tr><tr><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>iran</td><td rowspan=1 colspan=1>813.5</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0</td></tr><tr><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>uae</td><td rowspan=1 colspan=1>750.2</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>0</td></tr><tr><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>uzbekistan</td><td rowspan=1 colspan=1>680.8</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td></tr><tr><td rowspan=1 colspan=1>6</td><td rowspan=1 colspan=1>india</td><td rowspan=1 colspan=1>106.4</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>2</td></tr><tr><td rowspan=1 colspan=1>7</td><td rowspan=1 colspan=1>jordan</td><td rowspan=1 colspan=1>128.7</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>2</td></tr></table>
+
+# Rejected ("Trivial") examples:
+
+1. In the rank, it has 0 play - off.   
+2. ratar is in rank 2.   
+3. When member association is india, the points is 106.4.
+
+# Accepted ("Non-Trivial") examples:
+
+(Negation): iran is one of the two countries getting into the 4th stage. (Average): uae and qatar have an average of 1 play - off during the champion league.
+
+(Algorithmic): saudi arabia achieves 22.3 more points than qatar.
+
+(Comparison): india got lower points than jordan in the league.
+
+(Superlative): In the Champions League, saudi arabia achieves the highest points.
+
+(Combination): saudi arabia is the group stage 4 while iran is in group stage 3.
+
+Tips1: We set minimum length to 9, and sentences with more complicated grammar structures are preferred.   
+Tips2: Do not limited to only one type of description like superlative or relative.   
+Tips3: Copying the records from the table is encouraged, which can help avoid typos and mis-spelling as much as possible, .   
+Tips4: Do not vague words like "maybe", "perhaps", "good", "excellent", "most", etc.
+
+First Read the following table, then write five diverse non-trivial facts for this given table:
+
+Table Source: athletics at the 1952 summer olympics - men 's pole vault (https://en.wikipedia.org/wiki/Athletics_at_the_1952_Summer_Olympics_%E2%80%93_Men%27s_pole_vault)
+
+<table><tr><td rowspan=1 colspan=1>athlete</td><td rowspan=1 colspan=1>nationality</td><td rowspan=1 colspan=1>3.60</td><td rowspan=1 colspan=1>3.80</td><td rowspan=1 colspan=1>3.95</td><td rowspan=1 colspan=1>result</td></tr><tr><td rowspan=1 colspan=1>bob richards</td><td rowspan=1 colspan=1>united states</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>4.55 or</td></tr><tr><td rowspan=1 colspan=1>don laz</td><td rowspan=1 colspan=1>united states</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>4.50</td></tr><tr><td rowspan=1 colspan=1>ragnar lundberg</td><td rowspan=1 colspan=1>sweden</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>4.40</td></tr><tr><td rowspan=1 colspan=1>petro denysenko</td><td rowspan=1 colspan=1>soviet union</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>4.40</td></tr><tr><td rowspan=1 colspan=1>valto olenius</td><td rowspan=1 colspan=1>finland</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>4.30</td></tr><tr><td rowspan=1 colspan=1>bunkichi sawada</td><td rowspan=1 colspan=1>japan</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>xx0</td><td rowspan=1 colspan=1>4.20</td></tr><tr><td rowspan=1 colspan=1>volodymyr brazhnyk</td><td rowspan=1 colspan=1>soviet union</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>4.20</td></tr><tr><td rowspan=1 colspan=1>viktor knyazev</td><td rowspan=1 colspan=1>soviet union</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>4.20</td></tr><tr><td rowspan=1 colspan=1>george mattos</td><td rowspan=1 colspan=1>united states</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>4.20</td></tr><tr><td rowspan=1 colspan=1>erkki kataja</td><td rowspan=1 colspan=1>finland</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>4.10</td></tr><tr><td rowspan=1 colspan=1>tamás homonnay</td><td rowspan=1 colspan=1>sweden</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>4.10</td></tr><tr><td rowspan=1 colspan=1>lennart lind</td><td rowspan=1 colspan=1>hungary</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>4.10</td></tr><tr><td rowspan=1 colspan=1>milan milakov</td><td rowspan=1 colspan=1>yugoslavia</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>。</td><td rowspan=1 colspan=1>x0</td><td rowspan=1 colspan=1>4.10</td></tr><tr><td rowspan=1 colspan=1>rigas efstathiadis</td><td rowspan=1 colspan=1>greece</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>3.95</td></tr><tr><td rowspan=1 colspan=1>torfy bryngeirsson</td><td rowspan=1 colspan=1>iceland</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>3.95</td></tr><tr><td rowspan=1 colspan=1>erling kaas</td><td rowspan=1 colspan=1>norway</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>xxx</td><td rowspan=1 colspan=1>3.80</td></tr><tr><td rowspan=1 colspan=1>theodosios balafas</td><td rowspan=1 colspan=1>greece</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>。</td><td rowspan=1 colspan=1>xxx</td><td rowspan=1 colspan=1>3.80</td></tr><tr><td rowspan=1 colspan=1> jukka piironen</td><td rowspan=1 colspan=1>finland</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>x0</td><td rowspan=1 colspan=1>xX</td><td rowspan=1 colspan=1>3.80</td></tr><tr><td rowspan=1 colspan=1> zeno dragomir</td><td rowspan=1 colspan=1>romania</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>x0</td><td rowspan=1 colspan=1>xX</td><td rowspan=1 colspan=1>3.80</td></tr></table>
+
+Please write a non-trivial statement, minimum 9 words
+
+Please write a non-trivial statement, minimum 9 words
+
+Please write a non-trivial statement, minimum 9 words
+
+Please write a non-trivial statement, minimum 9 words
+
+Please write a non-trivial statement, minimum 9 words
+
+# Survey Instructions (Click to expand)
+
+Please first read a table to understand its content, an example is shown below, which contains the leaderboard of a competition.
+
+<table><tr><td rowspan=1 colspan=1>Player</td><td rowspan=1 colspan=1> Original Season</td><td rowspan=1 colspan=1>Gender</td><td rowspan=1 colspan=1> Eliminated</td><td rowspan=1 colspan=1>Placing</td></tr><tr><td rowspan=1 colspan=1>Derrick Kosinski</td><td rowspan=1 colspan=1>RR: X-Treme</td><td rowspan=1 colspan=1>Male</td><td rowspan=1 colspan=1>Winner</td><td rowspan=1 colspan=1>Winner</td></tr><tr><td rowspan=1 colspan=1>Evelyn Smith</td><td rowspan=1 colspan=1>Fresh Meat</td><td rowspan=1 colspan=1>Female</td><td rowspan=1 colspan=1>Winner</td><td rowspan=1 colspan=1>Winner</td></tr><tr><td rowspan=1 colspan=1>Johnny Devenanzio</td><td rowspan=1 colspan=1>RW: Key West</td><td rowspan=1 colspan=1>Male</td><td rowspan=1 colspan=1>Winner</td><td rowspan=1 colspan=1>Winner</td></tr><tr><td rowspan=1 colspan=1>Kenny Santucci</td><td rowspan=1 colspan=1>Fresh Meat</td><td rowspan=1 colspan=1>Male</td><td rowspan=1 colspan=1>Winner</td><td rowspan=1 colspan=1>Winner</td></tr><tr><td rowspan=1 colspan=1> Jenn Grijalva</td><td rowspan=1 colspan=1>RW: Denver</td><td rowspan=1 colspan=1>Female</td><td rowspan=1 colspan=1>Episode 8</td><td rowspan=1 colspan=1>Runner-Up</td></tr><tr><td rowspan=1 colspan=1>Paula Meronek</td><td rowspan=1 colspan=1>RW: Key West</td><td rowspan=1 colspan=1>Female</td><td rowspan=1 colspan=1>Episode 8</td><td rowspan=1 colspan=1>Runner-Up</td></tr><tr><td rowspan=1 colspan=1>Robin Hibbard</td><td rowspan=1 colspan=1>RW: San Diego</td><td rowspan=1 colspan=1>Female</td><td rowspan=1 colspan=1>Episode 8</td><td rowspan=1 colspan=1>Runner-Up</td></tr><tr><td rowspan=1 colspan=1>Ryan Kehoe</td><td rowspan=1 colspan=1>Fresh Meat</td><td rowspan=1 colspan=1>Male</td><td rowspan=1 colspan=1>Episode 8</td><td rowspan=1 colspan=1>Runner-Up</td></tr><tr><td rowspan=1 colspan=1>Dunbar Merrill</td><td rowspan=1 colspan=1>RW: Sydney</td><td rowspan=1 colspan=1>Male</td><td rowspan=1 colspan=1>Episode 8</td><td rowspan=1 colspan=1>9th Place</td></tr><tr><td rowspan=1 colspan=1>Johanna Botta</td><td rowspan=1 colspan=1>RW: Austin</td><td rowspan=1 colspan=1>Female</td><td rowspan=1 colspan=1>Episode8</td><td rowspan=1 colspan=1>10th Place</td></tr><tr><td rowspan=1 colspan=1> KellyAnne Judd</td><td rowspan=1 colspan=1>RW: Sydney</td><td rowspan=1 colspan=1>Female</td><td rowspan=1 colspan=1>Episode 8</td><td rowspan=1 colspan=1>11th Place</td></tr><tr><td rowspan=1 colspan=1>Dan Walsh</td><td rowspan=1 colspan=1>RR: Viewers&#x27; Revenge</td><td rowspan=1 colspan=1>Male</td><td rowspan=1 colspan=1>Episode 8</td><td rowspan=1 colspan=1>12th Place</td></tr><tr><td rowspan=1 colspan=1>Colie Edison</td><td rowspan=1 colspan=1>RW: Denver</td><td rowspan=1 colspan=1>Female</td><td rowspan=1 colspan=1>Episode 7</td><td rowspan=1 colspan=1>13th Place</td></tr><tr><td rowspan=1 colspan=1>Cohutta Grindstaff</td><td rowspan=1 colspan=1>RW: Sydney</td><td rowspan=1 colspan=1>Male</td><td rowspan=1 colspan=1>Episode 6</td><td rowspan=1 colspan=1>14th Place</td></tr><tr><td rowspan=1 colspan=1>Tyrie Ballard</td><td rowspan=1 colspan=1>RW: Denver</td><td rowspan=1 colspan=1>Male</td><td rowspan=1 colspan=1>Episode 5</td><td rowspan=1 colspan=1>15th Place</td></tr><tr><td rowspan=1 colspan=1>Ashli Robson</td><td rowspan=1 colspan=1>RW: Sydney</td><td rowspan=1 colspan=1>Female</td><td rowspan=1 colspan=1>Episode 4</td><td rowspan=1 colspan=1>16th Place</td></tr><tr><td rowspan=1 colspan=1>Rachel Robinson</td><td rowspan=1 colspan=1>RR: Campus Crawl</td><td rowspan=1 colspan=1>Female</td><td rowspan=1 colspan=1>Episode 3</td><td rowspan=1 colspan=1>17th Place</td></tr><tr><td rowspan=1 colspan=1>Abram Boise</td><td rowspan=1 colspan=1>RR: South Pacific</td><td rowspan=1 colspan=1>Male</td><td rowspan=1 colspan=1>Episode 2</td><td rowspan=1 colspan=1>18th Place</td></tr><tr><td rowspan=1 colspan=1>Dave Malinosky</td><td rowspan=1 colspan=1>RW: Hollywood</td><td rowspan=1 colspan=1>Male</td><td rowspan=1 colspan=1>Episode 2 (quit)</td><td rowspan=1 colspan=1>19th Place</td></tr><tr><td rowspan=1 colspan=1>Tonya Cooley</td><td rowspan=1 colspan=1>RW: Chicago</td><td rowspan=1 colspan=1>Female</td><td rowspan=1 colspan=1>Episode 1</td><td rowspan=1 colspan=1>20th Place</td></tr></table>
+
+You are given a sentence to describe a fact in the table, please follow the following two cases to finish the job:
+
+\* If the given sentence is fluent and consistent with the table, then please re-write it to make it "fake" based on the following criteria:
+
+1. Contradictory: it should still be a fluent and coherent, but it needs be explicitly contrdictory to the facts in the table.
+
+2. Do not simply add NOT to revert the sentence meaning.
+
+3. Do not write neutral or non-verifiable sentences, you need to confirm it in the table.
+
+3. The fake statement needs to be clear, explicit and natural, do not use vague or ambiguous words like "bad", "good", "many", etc.
+
+4. try to use diverse fake types during annotatoin.
+
+Example 1. Given statement: Ashli Robson was eliminated in episode 4.   
+Good Faking: Ashli Robson survives through episode 1 to episode 5.   
+Good Faking: Ashli Robson is not the only one eliminated in episode 4.   
+Bad Faking (Simply add not): Ashli Robson was not eliminated on episode 4. Bad Faking (Ambiguous, who is Ashli?): Ashli was not eliminated on episode 4.   
+Bad Faking (Irrelevant): Ashli was born in Mexico.   
+Bad Faking (Too subjective, what do you mean by "early"): AshlDerrick Kosinski lost the game very early.   
+Bad Faking (Not verifiable): AshlDerrick Kosinski was the most popular player. Example 2. Given statement: Tonya Cooley is in the 20th place.   
+Good Faking: Tonya Cooley is not the last in placing.   
+Good Faking: Tonya Cooley is eliminated in episode 1 but not the last in placing.   
+Bad Faking: (There is nothing larger than 20th) Tonya Cooley is after the 20th place.   
+Bad Faking: (Half Wrong/half Right) When the gneder is female, the player is Tonya Colley.   
+Bad Faking (Introduce values outside the table): Tonya Cooley is in the 43th place.   
+Bad Faking (Typo): Tonya Cooler is in the 20th palace.
+
+\* If the given statement is erroneous (see following), please type in N/A in the input box.
+
+1. critical grammar error like missing verbs, nouns, etc. Do not count small errors like tense, singular/plural, case errors.   
+2. serious typo, misspelling.   
+3. the described fact is contradictory to the table.
+
+You can use the highlight button to help you find the mentions in the table, you can use either upper or lower case, not important
+
+First Read the given tables, then rewrite the statements to make them fake:
+
+Table Source: 2003 - 04 isu junior grand prix (https://en.wikipedia.org/wiki/2003%E2%80%9304_ISU_Junior_Grand_Prix)   
+
+<table><tr><td rowspan=1 colspan=1>rank</td><td rowspan=1 colspan=1>nation</td><td rowspan=1 colspan=1>gold</td><td rowspan=1 colspan=1>silver</td><td rowspan=1 colspan=1>bronze</td><td rowspan=1 colspan=1>total</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>russia</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>14</td><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>32</td></tr><tr><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>united states</td><td rowspan=1 colspan=1>9</td><td rowspan=1 colspan=1>6</td><td rowspan=1 colspan=1>7</td><td rowspan=1 colspan=1>22</td></tr><tr><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>canada</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>16</td></tr><tr><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1> japan</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>13</td></tr><tr><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>hungary</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>6</td></tr><tr><td rowspan=1 colspan=1>6</td><td rowspan=1 colspan=1>czech republic</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>4</td></tr><tr><td rowspan=1 colspan=1>6</td><td rowspan=1 colspan=1>ukraine</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>4</td></tr><tr><td rowspan=1 colspan=1>6</td><td rowspan=1 colspan=1>italy</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>4</td></tr><tr><td rowspan=1 colspan=1>7</td><td rowspan=1 colspan=1>sweden</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>3</td></tr><tr><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>israel</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>2</td></tr><tr><td rowspan=1 colspan=1>9</td><td rowspan=1 colspan=1>finland</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>9</td><td rowspan=1 colspan=1>france</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>1</td></tr></table>
+
+Hightlight Mentions, Click Me!
+
+Given Statement: russia won the most silver medals in the grand prix
+
+Please rewrite a sentence which is contradictory to the table
+
+Hightlight Mentions, Click Me!
+
+Given Statement: france and finland won the least medals in the grand prix
+
+Please rewrite a sentence which is contradictory to the table
+
+Hightlight Mentions, Click Me!
+
+Given Statement: hungary and finland were the only countries that idd not win any silver medals
+
+Please rewrite a sentence which is contradictory to the table
+
+Hightlight Mentions, Click Me!
+
+Given Statement: the united states won more gold medals than canada
+
+Please rewrite a sentence which is contradictory to the table
+
+Hightlight Mentions, Click Me!
+
+Given Statement: canada won the most bronze medals in the grand prix
+
+Please rewrite a sentence which is contradictory to the table

parse/train/tHzvH4Rv1Qa/tHzvH4Rv1Qa.md

@@ -0,0 +1,239 @@
+# Generative Occupancy Fields for 3D Surface-Aware Image Synthesis
+
+Xudong $\mathbf { X } \mathbf { u } ^ { \dag }$ Xingang Pan‡ Dahua Lin† Bo Dai§ †CUHK - SenseTime Joint Lab, The Chinese University of Hong Kong   
+‡Max Planck Institute for Informatics $^ { \ S } S$ - Lab, Nanyang Technological University   
+$^ \dag \{ \tt x x 0 1 8$ , dhlin}@ie.cuhk.edu.hk ‡xpan@mpi-inf.mpg.de §bo.dai@ntu.edu.sg
+
+# Abstract
+
+The advent of generative radiance fields has significantly promoted the development of 3D-aware image synthesis. The cumulative rendering process in radiance fields makes training these generative models much easier since gradients are distributed over the entire volume, but leads to diffused object surfaces. In the meantime, compared to radiance fields occupancy representations could inherently ensure deterministic surfaces. However, if we directly apply occupancy representations to generative models, during training they will only receive sparse gradients located on object surfaces and eventually suffer from the convergence problem. In this paper, we propose Generative Occupancy Fields (GOF), a novel model based on generative radiance fields that can learn compact object surfaces without impeding its training convergence. The key insight of GOF is a dedicated transition from the cumulative rendering in radiance fields to rendering with only the surface points as the learned surface gets more and more accurate. In this way, GOF combines the merits of two representations in a unified framework. In practice, the training-time transition of start from radiance fields and march to occupancy representations is achieved in GOF by gradually shrinking the sampling region in its rendering process from the entire volume to a minimal neighboring region around the surface. Through comprehensive experiments on multiple datasets, we demonstrate that GOF can synthesize high-quality images with 3D consistency and simultaneously learn compact and smooth object surfaces. Our code is available at https://github.com/SheldonTsui/GOF_NeurIPS2021.
+
+# 1 Introduction
+
+Deep generative adversarial networks [1–4] have demonstrated their superiority in synthesizing photorealistic and striking images. However, these models are often constrained in the 2D domain, struggling to generate 3D consistent images, let alone grasping the underlying 3D object shapes. 3D-aware image synthesis thus becomes an appealing and promising choice as it learns a 3D representation explicitly from a collection of unposed images. Consequently, it can not only synthesize 3D consistent images by manually controlling the rendering camera poses, but also pave the way for various downstream tasks such as shape editing and relighting.
+
+Inspired by the success of neural radiance fields (NeRF) [5] in 3D scene modeling, recent 3D-aware generative models, referred to as generative radiance fields (GRAFs), have applied NeRF as the explicit 3D representation for image synthesis [6, 7]. With the help of NeRF, they are capable of hallucinating photorealistic images in a 3D consistent manner. Moreover, since NeRF holds the superior ability for rendering translucent objects by compositing colored densities along each ray in its volume rendering process, it also significantly facilitates the training of GRAFs as gradients are naturally distributed over the entire volume. However, they still incur an inevitable incapacity of capturing an accurate and compact object surface. As shown in Fig. 1(a), the state-of-the-art GRAF model pi-GAN is prone to predict diffused object surfaces, as the volume densities are smoothly spread around the surfaces. Such diffused surfaces could significantly hamper the applications of GRAF models in downstream tasks such as shape recovery. Moreover, under different light conditions, the artifacts of surfaces could be amplified and inherited through the rendering process, resulting in synthesized images that are messy and faulty.
+
+![](images/8e4cfc63bb10b58b927f5606b09142659b4d5b7e80778cc5cc03f1ee4f7ac8b7.jpg)  
+Figure 1: (a) The cumulative rendering weights (color weights) of our approach GOF more focus on the surface (y-axis) than previous methods like pi-GAN [6], which indicates our predicted volume densities more concentrate on the object surfaces. (b) Owing to the diffused volume densities, the preceding method pi-GAN captures messy surface normals and object shapes. Moreover, the image rendered only with the surface points is quite noisy. In contrast, more surface-centralized densities predicted by our method ensure compact and smooth object surfaces thus enable a high-quality surface rendering during inference. (Zoom in for best view)
+
+In this work, we propose Generative Occupancy Fields (GOF), a novel GRAF-like image synthesis model that can learn compact object surfaces. GOF is inspired by the design of occupancy networks [8] that implicitly represents a 3D surface with the continuous decision boundary of a neural classifier. In this way, occupancy networks are capable of effectively locating surfaces via root-finding and encouraging the compactness of modeled surfaces inherently. However, GOF avoids directly applying such a design to 3D-aware image synthesis. While occupancy networks require precise object masks to train [9, 10], a more crucial factor is that they rely on the surface points for differentiable rendering [11, 12, 9, 13]. A generative model equipped with occupancy representations will thus meet severe convergence problems during training due to the sparsity of gradients. To unify the merits of both NeRF and occupancy networks for 3D-aware image synthesis, GOF adopts the design of GRAFs and at the same time leverages a nontrivial transition from the cumulative rendering to rendering with only the surface points, i.e. start from radiance fields and march to occupancy representations. Specifically, GOF will reinterpret the alpha values in the cumulative rendering process as occupancy values, so that it can locate the learned surface via root-finding. Subsequently, it can naturally encourage the compactness of learned surfaces by gradually shrinking the sampling region in the rendering process from the entire volume to a minimal neighboring region around the surface.
+
+Thanks to the unified integration of radiance fields and occupancy representations, GOF can benefit from the representation effectiveness of radiance fields while ensuring the compactness of learned object surfaces through the shrinking process. As presented in Fig. 1(a), in GOF the distribution of cumulative rendering weights concentrates more closely around object surfaces compared to that of pi-GAN, eventually resulting in a compact and smooth surface. Moreover, GOF can thus alternatively render an image only with points on the learned surfaces like occupancy networks as illustrated in Fig. 1 (b). And during inference such a rendering scheme has the potential to alleviate the burden of sampling a large number of points along each ray for synthesizing a single image. Through exhaustive experiments on synthetic and real-world datasets, we demonstrate that GOF can achieve state-of-the-art performance on 3D-aware image synthesis. Meanwhile, it is capable of capturing compact and accurate 3D shapes that empower its applications in various downstream tasks such as 3D shape reconstruction. We validate this point by quantitative results of 3D shape reconstruction on the Synface dataset. Finally, we have also verified the ability of GOF in rendering high-quality images with only the surface points, which is hardly achievable in previous approaches.
+
+# 2 Related Work
+
+Neural implicit function for 3D representations. A plethora of works [14, 8, 15–21] has exploited neural implicit functions for 3D geometry modeling. Among these works, neural radiance fields (NeRF) [5] has attracted growing attention due to its compelling results on novel view synthesis. It leverages an MLP network to approximate the radiance fields of static 3D scenes. And by learning to reconstruct existing views, it is capable of capturing 3D geometric details from only 2D supervision. A series of succeeding variants of NeRF have been proposed to improve it, including utilizing the spatial sparsity to reduce its computational complexity [22, 23], refining the rendering process to improve its efficiency [24, 25], as well as adopting reflectance decompositions to enhance its modeling capacity [26, 27]. There are also works that capitalize on the differentiable rendering of neural implicit functions for 3D reconstruction [11, 12, 9, 13, 28, 29]. Specifically, SDFDiff [12] relies on the interpolation of eight neighboring SDF samples around the surface intersection to obtain the derivatives, while Atzmon et al [28] use a sample network to relate samples’ positions to network parameters and thus achieve an improved generalization ability. More interestingly, by adopting occupancy representations, DVR [11] and IDR [9] show volumetric rendering is inherently differentiable so that network parameters can be optimized directly with derived analytic gradients. Different from methods aforementioned above, GOF is a generative model for 3D-aware image synthesis that can learn 3D representations from a set of 2D images with unknown camera poses.
+
+Generative 3D-aware image synthesis. In order to synthesize 3D consistent images, researchers have explored a lot on how to incorporate 3D representations into the classical GAN model [1]. Some methods [30–32] resort to learning from 3D data directly, yet the requirement of 3D supervision limits their practical applicability. A more appealing alternative is thus learn from unposed 2D images in an unsupervised manner. Preceding works along this line of research adopt voxels as their intermediate 3D representations [33–35] and achieve explicit control over the pose of synthesized images. Inspired by the superior representation capacity of radiance fields over voxels, recent attempts [6, 7, 36] have replaced voxels with neural radiance fields [5] to improve the fidelity of synthesized 3D consistent images. Despite the striking performance, these models, referred to as generative radiance fields (GRAFs), tend to predict diffused object surfaces, which impedes its applicability in various downstream tasks. In this work, GOF aims at resolving this problem of GRAFs by combining them with the perspective of occupancy networks [8] and recent successes of recovering smooth and accurate shapes from natural images [37–40]. Recently, three concurrent works, UNISURF [10], NeuS [41] and VolSDF [42], also combine implicit surfaces and radiance fields in a unified framework, sharing similar spirits with our proposed GOF but different in tasks and focuses. Specifically, They focus on multi-view 3D reconstruction and attempt to alleviate the requirement of training-time precise masks through the integration of radiance fields and occupancy representations. Nevertheless, they still require images with ground-truth poses for training. By contrast, GOF targets on the challenging task of 3D-aware image synthesis, where the synthesized images should be not only natural and vivid, but also consistent in the 3D space. By integrating radiance fields and occupancy representations, GOF is able to facilitate the convergence of GRAFs and ensure the compactness of learned object surfaces. Compared to existing GRAFs, the applicability of GOF is thus significantly broadened.
+
+# 3 Methodology
+
+We propose generative occupancy fields (GOF), a novel synthesis model, belonging to generative radiance fields and aiming to learn from unposed images. Conditioned on a latent code $\mathbf { z } \sim p _ { \mathbf { z } }$ , our generator $g _ { \theta }$ can generate a 3D radiance field $\mathbf { R }$ , from which we can render a realistic image with a sampled camera pose $\xi \sim p _ { \xi }$ and simultaneously recover smooth and compact object surfaces. In the following, we first present the background of neural radiance fields, and then introduce our proposed GOF model in detail.
+
+# 3.1 Neural Radiance Fields
+
+We adopt neural radiance fields (NeRF) as our explicit 3D representation for image synthesis, owing to its strong performance in novel view synthesis on complex scenes. NeRF represents a static scene as per-point volume densities and view-dependent RGB colors. Given a 3D point $\mathbf { x } \in \mathbb { R } ^ { 3 }$ in space and a view direction $\mathbf { d } \in \mathbb { R } ^ { 3 }$ , NeRF capitalizes on a multi-layer perceptron (MLP) to predict the volume density $\sigma ( \mathbf { x } ) \in \mathbb { R }$ and the emitted color $\mathbf { c } ( \mathbf { x } , \mathbf { d } ) \in \mathbb { R } ^ { 3 }$ . To render a novel view for the scene, NeRF leverages the classic volume rendering technique [43] to estimate the color of each pixel. It starts by accumulating the colored densities of $N$ points $\left\{ { \bf x } _ { i } = { \bf o } + t _ { i } { \bf d } \right\}$ sampled within near and far bounds $[ t _ { n } , t _ { f } ]$ along the camera ray $\mathbf { r } ( t ) = \mathbf { o } \overset { \cdot } { + } t \mathbf { d }$ , where $\mathbf { o }$ stands for the camera origin. The integrated color is then estimated via alpha composition as follows:
+
+![](images/bd983df8c4534842b7ff7b61a0d089ed1c071f2c9a46de2898073258adf48897.jpg)  
+Figure 2: Shrinking process. During the training, the sampling interval $\Delta$ is initially a half of the distance between near $t _ { n }$ and far bounds $t _ { f }$ and shrinks gradually to a pre-defined value $\Delta _ { \mathrm { m i n } }$ . For inference, we can use cumulative rendering by sampling points in the minimal interval $\Delta _ { \mathrm { m i n } }$ and alternatively render only with the surface points.
+
+$$
+\hat { \mathbf { C } } ( \mathbf { r } ) = \sum _ { i = 1 } ^ { N } T _ { i } \Big ( 1 - \exp \big ( - \sigma ( \mathbf { x } _ { i } ) \delta _ { i } \big ) \Big ) \mathbf { c } ( \mathbf { x } _ { i } , \mathbf { d } ) , \mathrm { ~ w h e r e ~ } T _ { i } = \exp ( - \sum _ { j = 1 } ^ { i - 1 } \sigma ( \mathbf { x } _ { j } ) \delta _ { j } ) ,
+$$
+
+where $\delta _ { i } = | x _ { i + 1 } - x _ { i } |$ is the distance between adjacent points. Note that, equation (1) is naturally differentiable and NeRF can be directly optimized through the reconstruction error of existing views.
+
+# 3.2 3D Surface-Aware Image Synthesis via Generative Occupancy Fields
+
+To apply NeRF as the 3D representation, the proposed generative occupancy fields (GOF) incorporates an additional latent code $\mathbf { z } \sim p _ { \mathbf { z } }$ into NeRF, such that synthesizing an image follows a reformulated cumulative rendering process:
+
+$$
+\hat { \mathbf { C } } ( \mathbf { r } , \mathbf { z } ) = \sum _ { i = 1 } ^ { N } T _ { i } \Big ( 1 - \exp \big ( - \sigma _ { \theta } ( \mathbf { x } _ { i } , \mathbf { z } ) \delta _ { i } \big ) \Big ) \mathbf { c } _ { \theta } \big ( \mathbf { x } _ { i } , \mathbf { d } , \mathbf { z } \big ) , \mathrm { ~ w h e r e ~ } T _ { i } = \exp \big ( - \sum _ { j = 1 } ^ { i - 1 } \sigma _ { \theta } ( \mathbf { x } _ { j } , \mathbf { z } ) \delta _ { j } \big ) .
+$$
+
+However, directly training GOF according to Eq.(2) fails to maintain the surface compactness as reported in previous approaches [6, 7]. Actually, such a defect arises from an inevitable “shape-color ambiguity” of the cumulative rendering process, i.e., small perturbations on surfaces still lead to realistic RGB images which are enough to fool the discriminator.
+
+Owing to the constrained range of poses seen at training, the discriminator is less motivated to further concentrate the color weights $w _ { i } \bar { = } T _ { i } \big ( 1 - \exp ( - \sigma _ { \theta } ( \mathbf { \bar { x } } _ { i } , \mathbf { z } ) \delta _ { i } ) \big )$ aforementioned in Fig. 1 (a) on the exact object surface. On the other hand, we observe that although leading to diffused surfaces at the end, color weights $w _ { i }$ gradually concentrate around the object surface as the training proceeds. Inspired by this observation, in GOF we propose a training-time operation to facilitate the concentration of color weights $w _ { i }$ . The basic idea is gradually shrinking the sample region in the cumulative rendering process from the entire volume to a narrow interval around the surface, so that color weights are enforced to continuously move towards the exact surface.
+
+To enable the proposed training-time shrinking process, GOF is required to locate the surface by thresholding the predicted densities $\sigma _ { \boldsymbol { \theta } } ( \mathbf { x } , \mathbf { z } )$ , assuming points on the surface have the largest densities, However, values of the densities predicted in generative radiance fields could range from 0 to 50, making it hard to determine an effective threshold $\tau$ during the whole training period. On the other hand, in the cumulative rendering process shown in Eq.(2), we found that the intermediate alpha values used for numerical stability inherently fall in a fixed value range as:
+
+$$
+\alpha _ { \theta } ( \mathbf { x } _ { i } , \mathbf { z } ) = 1 - \exp ( - \sigma _ { \theta } ( \mathbf { x } _ { i } , \mathbf { z } ) \delta _ { i } ) \in [ 0 , 1 ] .
+$$
+
+More importantly, these alpha values $\alpha _ { \boldsymbol { \theta } } ( \mathbf { x } , \mathbf { z } )$ come close to 1 for points in the occupied space while approaching 0 for points in the free space, making them resemble the occupancy values [8] in both quantity and semantics. Inspired by the similarity, we thus propose to reformulate generative radiance fields by predicting alpha values $\alpha _ { \boldsymbol { \theta } } ( \mathbf { x } , \mathbf { z } )$ directly instead of volume densities $\sigma _ { \boldsymbol { \theta } } \bar { ( } \mathbf { x } , \mathbf { z } )$ . In the mean time, we reinterpret the alpha values as occupancy values, and subsequently locate surfaces with root-finding, a more effective strategy originated in occupancy networks [11]. According to the above reformulation and reinterpretation, we thus dub our method as Generative Occupancy Fields.
+
+As GOF estimates alpha values instead of volume densities, the original volume rendering process in Eq.(2) conditioned on the latent code $\mathbf { z }$ is reformulated as
+
+$$
+\hat { \mathbf { C } } ( \mathbf { r } , \mathbf { z } ) = \sum _ { i = 1 } ^ { N } \alpha _ { \theta } \big ( \mathbf { x } _ { i } , \mathbf { z } \big ) \prod _ { j < i } \big ( 1 - \alpha _ { \theta } \big ( \mathbf { x } _ { j } , \mathbf { z } \big ) \big ) \mathbf { c } _ { \theta } \big ( \mathbf { x } _ { i } , \mathbf { d } , \mathbf { z } \big ) ,
+$$
+
+where the value range of $\alpha _ { \theta } ( \mathbf { x } _ { i } , \mathbf { z } )$ is guaranteed with a sigmoid function. And to locate the surface via root-finding, for a specific ray $\dot { \mathbf { r } } ( t ) = \mathbf { o } + t \mathbf { d }$ we will evenly sample $M$ points $\begin{array} { r } { \left\{ \mathbf { x } _ { k } = \mathbf { o } + t _ { k } \mathbf { d } ; k = \right. } \end{array}$ $1 , . . . , M \}$ that partition the entire volume $[ t _ { n } , t _ { f } ]$ into $M$ equally-spaced bins. After obtaining the corresponding alpha values $\{ \alpha _ { \boldsymbol { \theta } } ( \mathbf { x } _ { k } , \mathbf { z } ) ; k \stackrel { - } { = } 1 , . . . , M \}$ by querying the generator $g _ { \theta }$ , the surface $s$ is located in the $k ^ { \dot { S } }$ -th bin where $\alpha \theta$ changes for the first time from free space $( \alpha _ { \theta } < \tau )$ to occupied space $( \alpha _ { \theta } < \tau )$ ):
+
+$$
+k ^ { S } = \underset { k } { \mathrm { a r g m i n } } \big ( \alpha _ { \theta } ( \mathbf { x } _ { k } , \mathbf { z } ) < \tau \leq \alpha _ { \theta } ( \mathbf { x } _ { k + 1 } , \mathbf { z } ) \big ) ,
+$$
+
+where $\tau$ is a pre-defined threshold. In practice, we empirically set $\tau$ as 0.5. In order to find the surface point $\mathbf { x } _ { s } = \mathbf { o } + t _ { s } \mathbf { d }$ more precisely, we further apply the above secant method iteratively for $m _ { s }$ times, resulting in a fine-grained bin $\left[ \mathbf { x } _ { k ^ { s } } , \mathbf { x } _ { k ^ { s } + 1 } \right]$ . It’s worth noting that the $M$ sampled points are only used for root-finding. Thus they do not require the computation of gradients in the implementation.
+
+Based on the located surface $s$ , we can thus successfully conduct the proposed shrinking process, which is schematically elaborated in Fig. 2. Specifically, when sampling $N$ points for Eq.(4) at each training step, we will only sample within a region neighboring the surface $[ t _ { s } - \Delta , t _ { s } + \Delta ]$ :
+
+$$
+t _ { i } \sim \mathcal { U } \left[ t _ { s } - \Delta + \frac { 2 i - 2 } { N } \Delta , t _ { s } - \Delta + \frac { 2 i } { N } \Delta \right] , \mathrm { w h e r e } i = 1 , 2 , . . . , N .
+$$
+
+$\Delta$ is the sampling interval, which is set to $\Delta _ { \mathrm { i n i t } } = ( t _ { f } - t _ { n } ) / 2$ at the beginning, a half of the distance between near $t _ { n }$ and far bounds $t _ { f }$ . And it will decrease monotonically with an exponential decay rate $\gamma$ until it drops to a pre-defined minimal value $\Delta _ { \mathrm { m i n } }$ . Formally, $\Delta _ { n } = \mathrm { m a x } ( \Delta _ { \mathrm { i n i t } } \exp ( - \gamma n ) , \Delta _ { \mathrm { m i n } } )$ for $n$ -th decaying step. Additionally, during training when the estimated $t _ { s }$ is too close to the near or the far bound so that the sampling region $[ t _ { s } - \Delta , t _ { s } + \Delta ]$ exceeds the original range $[ t _ { n } , t _ { f } ]$ , we will shift the region $[ t _ { s } - \Delta , t _ { s } + \Delta ]$ back to within $[ t _ { n } , t _ { f } ]$ . As shown in Fig. 2, at the beginning of training, points sampled for Eq.(4) will cover the entire volume, leading to dispersed gradients which facilitate the convergence of GOF. And as the training goes, the predicted surface will become more and more accurate, which is the outcome of gradually refining the sampling region, and in turn also makes the above shrinking operation valid.
+
+Thanks to the dedicated shrinking process, the color weights $w _ { i }$ can successfully concentrate on the object surface as illustrated in Fig. 1(a). As a result, GOF is capable of synthesizing highfidelity images in a 3D-consistent manner and simultaneously capturing compact object surfaces. During inference, to synthesize an image under a random camera pose $\xi \sim p _ { \xi }$ , the generator $g _ { \boldsymbol { \theta } }$ will fetch a truncated latent code $\hat { \mathbf { z } }$ and sample $N$ points $\{ { \bf { x } } _ { i } \}$ on each ray within the minimal region $[ t _ { s } - \Delta _ { \mathrm { m i n } } , t _ { s } + \Delta _ { \mathrm { m i n } } ]$ for the rendering as in Eq.(4). An important benefit of learning a compact object surface is that we can effectively reduce the number of sampled points for rendering, even using only one point on each ray, i.e. the surface point. As shown in Fig. 1 (b), the image rendered with only the surface point is almost indistinguishable from that with multiple points. Such equivalence can be guaranteed theoretically when $\Delta _ { \operatorname* { m i n } }  0$ , and we include the proof in the supplementary material.
+
+# 3.3 Loss Functions
+
+Instead of training on posed 2D images, the proposed GOF leverages a corpus of unposed images for 3D-aware image synthesis, where multiple loss functions are adopted.
+
+GAN Loss. Following pi-GAN [6], a GAN loss is used where GOF synthesizes fake images by randomly sampling camera poses $\xi$ from a dataset-related distribution $p _ { \xi }$ and rendering according to Eq.(4). Denote $I$ as a real image from the data distribution $p _ { \mathcal { D } }$ , the non-saturating GAN loss can be described as follows:
+
+$$
+\begin{array} { r l } & { \mathcal { L } _ { \mathrm { o r i g i n } } ( \theta _ { D } , \theta _ { G } ) = { \bf E } _ { { \bf z } \sim p _ { \bf z } , \xi \sim p _ { \xi } } \left[ f \Big ( D _ { \theta _ { D } } ( G _ { \theta _ { G } } ( { \bf z } , \xi ) ) \Big ) \right] } \\ & { \quad \quad \quad \quad \quad + { \bf E } _ { I \sim p _ { \mathcal D } } \left[ f ( - D _ { \theta _ { D } } ( I ) ) + \lambda | \nabla D _ { \theta _ { D } } ( I ) | ^ { 2 } \right] , } \\ & { \quad \quad \quad \quad \quad \mathrm { w h e r e ~ } f ( u ) = - \log ( 1 + \exp ( - u ) ) . } \end{array}
+$$
+
+However, $\mathcal { L } _ { \mathrm { o r i g i n } }$ alone is not sufficient to guide the training, which may lead to messy images with smoke-like artifacts. Therefore, two more regularizations are incorporated to reduce artifacts and further smooth the learned surfaces.
+
+Normal Regularization. The first regularization is a prior on the surface normal smoothness, which is specially useful for learning from 2D real-world images [11]. In GOF, this normal prior is only employed for the surface points $\mathbf { x } _ { s } \in \mathcal { S }$ to encourage a natural and smooth surface:
+
+$$
+\mathcal { L } _ { \mathrm { n o r m a l } } = \sum _ { \mathbf { x } _ { s } \in \mathcal { S } } | | \mathbf { n } _ { \theta } ( \mathbf { x } _ { s } , \mathbf { z } ) - \mathbf { n } _ { \theta } ( \mathbf { x } _ { s } + \epsilon , \mathbf { z } ) | | _ { 2 } ,
+$$
+
+where $\epsilon$ is a small random 3D perturbation and $\mathbf { n } _ { \theta }$ denotes the normal vector, which can be computed by $\begin{array} { r } { \mathbf { n } _ { \theta } ( \mathbf { x } , \mathbf { z } ) = \nabla _ { \mathbf { x } } \alpha _ { \theta } ( \mathbf { x } , \mathbf { z } ) / | | \mathcal { \bar { \nabla } } _ { \mathbf { x } } \alpha _ { \theta } ( \mathbf { x } , \mathbf { z } ) | | _ { 2 } } \end{array}$ .
+
+Opacity Regularization. Since alpha values predicted in GOF can be regarded as occupancy values, ideally the entropy of them should be 0 so that $\alpha _ { \boldsymbol { \theta } } ( \mathbf { x } , \mathbf { z } )$ values will equal 1 for points in the occupied space and 0 for points in the free space. We thus apply the second opacity regularization, aiming to reduce the entropy of predicted alpha values:
+
+$$
+\mathcal { L } _ { \mathrm { o p a c i t y } } = \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \log ( \alpha _ { \theta } ( \mathbf { x } _ { i } , \mathbf { z } ) ) + \log ( 1 - \alpha _ { \theta } ( \mathbf { x } _ { i } , \mathbf { z } ) ) .
+$$
+
+In summary, the final loss function for training GOF can be written as:
+
+$$
+\mathcal { L } ( \theta , \phi ) = \mathcal { L } _ { \mathrm { o r i g i n } } ( \theta , \phi ) + \lambda _ { \mathrm { n o r m a l } } \mathcal { L } _ { \mathrm { n o r m a l } } + \lambda _ { \mathrm { o p a c i t y } } \mathcal { L } _ { \mathrm { o p a c i t y } } ,
+$$
+
+where $\lambda _ { \mathrm { { n o r m a l } } }$ and $\lambda _ { \mathrm { o p a c i t y } }$ are both balancing coefficients.
+
+# 4 Experiments
+
+Implementation Details. Unless stated otherwise, in all experiments we set $N$ , the number of points sampled for rendering, to 12, and set $M$ , the number of bins used in root-finding, to 12. As discussed in Sec.3.2, we apply an iterative process in root-finding. In practice, the number of iterations is set to $m _ { s } = 3$ times. During inference, GOF requires $M + m _ { s } + N$ queries to obtain the color of a pixel, while existing methods require $2 N$ queries due to the use of a hierarchical sampling strategy. Recall it is sufficient for GOF to sample only the surface point to render an image, GOF is thus capable of using just $M + m _ { s } + 1$ queries, potentially speeding up the rendering process in off-line applications. More training and implementation details can be found in the supplemental material.
+
+Datasets. To assess our method comprehensively, we conduct experiments on three datasets, namely CelebA [44], BFM [45], and Cats [46]. Specifically, CelebA is a high-resolution face dataset containing 200, 000 diverse face images. Following pi-GAN [6], we crop all images in CelebA from the top of the hair to the bottom of the chin as a pre-processing step. As for the Cats dataset, it contains 6, 444 cat faces of size $1 2 8 \times 1 2 8$ . Finally, BFM is a synthetic face dataset rendered with Basel Face Model, where each face is paired with a ground-truth depth map, making it a good benchmark for quantitatively evaluating the quality of learned surfaces.
+
+Comparison with baselines. To validate the effectiveness of GOF, we compare it with two representative GRAF methods, namely GRAF [7] and pi-GAN. Firstly, Fig. 3 demonstrates the qualitative comparison between these three methods, where we include the synthesized images, the learned surfaces in the form of 3D meshes, as well as the corresponding normal maps. As can be observed, GRAF struggles to render good images, let alone estimate compact and reasonable underlying surfaces. Compared to GRAF, pi-GAN can synthesize images and estimate corresponding surfaces with improved quality. However, messy parts can be clearly recognized on its learned surfaces and normal maps, indicating it is incapable of capturing the compact 3D geometric details. In contrast to both pi-GAN and GRAF, the proposed GOF is shown to hallucinate realistic images with 3D consistency and simultaneously learn smooth surface normals as well as compact object surfaces, which verifies the benefit of adopting the transition from radiance fields to occupancy fields. More qualitative results of synthesized images and corresponding surfaces are included in Fig. 4.
+
+Table 1: Quantitative results $( 1 2 8 \times 1 2 8 \mathrm { p x } )$ ) on BFM, CelebA and Cats datasets, on three metrics Fréchet Inception Distance (FID), Inception Score (IS) and the weighted variance of sampled depth $\Sigma _ { t _ { i } } ( \times 1 0 ^ { - 4 } )$ .
+
+![](images/7cbd855904b7fe282b61597f75dac06c7e87466d77949262c3f765c73762a11b.jpg)  
+Figure 3: Qualitative comparison on BFM (top), CelebA (middle), and Cats (bottom) datasets. Our method synthesizes realistic images while ensuring compact object surfaces.
+
+Table 2: Comparisons on the compactness and accuracy of learned surfaces.   
+
+<table><tr><td>Method</td><td>SIDE↓</td><td>MAD↓</td></tr><tr><td>Supervised</td><td>0.412</td><td>10.84</td></tr><tr><td>Unsup3d [37]</td><td>0.795</td><td>16.51</td></tr><tr><td>GRAF[7]</td><td>1.866</td><td>26.69</td></tr><tr><td>pi-GAN [6]</td><td>0.727</td><td>20.46</td></tr><tr><td>GAN2Shape [38]</td><td>0.759</td><td>14.94</td></tr><tr><td>Ours</td><td>0.779</td><td>13.81</td></tr></table>
+
+Table 3: Comparisons on the geometry properties of learned surfaces. We report mean curvature $( \mathbf { M C } ) ( \times 1 0 ^ { - 3 } )$ and mean geodesic distance(MGD) between random points to assess the geometry properties of recovered surfaces.   
+
+<table><tr><td colspan="2"></td><td>BFM</td><td>CelebA</td><td>Cats</td></tr><tr><td>MC↓</td><td>pi-GAN Ours</td><td>16.84 12.25</td><td>25.94 23.13</td><td>34.05 30.14</td></tr><tr><td>MGD↓</td><td>pi-GAN Ours</td><td>0.483 0.226</td><td>0.450 0.231</td><td>0.494 0.317</td></tr></table>
+
+![](images/dcca993f4bffe3c3b1f7a9950ad87ce0db78468086b69de1bfce327dbd7d8445.jpg)  
+Figure 4: Generated images and their 3D meshes on CelebA and Cats datasets.
+
+To quantitatively evaluate the quality of generated images, we report the Fréchet Inception Distance (FID) scores and Inception Score (IS) scores in Table 1. On these two metrics, GOF demonstrates substantial improvements over baseline methods. To further measure the compactness of learned surfaces, the concentration of color weights $w _ { i }$ as mentioned in Fig. 1 (a) is also computed. Specifically, We sample $N = 3 6$ equally-spaced points $\left\{ { \bf x } _ { i } = { \bf o } + t _ { i } { \bf d } \right\}$ within near and far bounds $[ t _ { n } , t _ { f } ]$ and calculate the corresponding color weights $w _ { i } , i = 1 , 2 , . . . , N$ . Actually, the weighted variance of these samples’ depth $t _ { i }$ reflects the concentration of color weights in a single image:
+
+$$
+\Sigma _ { t _ { i } } = \frac { N } { ( N - 1 ) \sum _ { i = 1 } ^ { N } w _ { i } } \sum _ { i = 1 } ^ { N } w _ { i } ( t _ { i } - \bar { t } ) ^ { 2 } , \mathrm { ~ w h e r e ~ } \bar { t } = \sum w _ { i } t _ { i } \Big / \sum w _ { i } .
+$$
+
+Intuitively, a smaller variance implies the learned surface is more compact. Finally, for each method, the overall concentration of color weights is averaged over 1000 randomly synthesized images at the $2 5 6 \times 2 5 6$ resolution. The results in terms of this new metric are also included in Table 1.
+
+For the quality of learned surfaces, we first evaluate the compactness and accuracy of surfaces on the BFM dataset, since it contains ground-truth depth maps. Specifically, $5 0 K$ images are generated by each method, together with their corresponding depth maps. For each method, we train a separate CNN on these generated images and depth maps to predict depths from images. Subsequently, we can measure the accuracy of learned surfaces by running the CNN on the test split of BFM and comparing its outputs to the ground-truth depth maps using the scale-invariant depth error (SIDE) and the mean angle deviation (MAD). While MAD focuses more on the compactness of surfaces, SIDE emphasizes more on the accuracy of depth. As shown in Table 2, GOF significantly outperforms baseline methods on the MAD metric and is comparable to strong baselines on the SIDE metric. Moreover, we also report mean curvature (MC) and mean geodesic distance (MGD) between random points to assess the geometry properties of learned surfaces. The lower these two metrics, the smoother recovered object surfaces. Owing to the absence of such two metrics on ground-truth surfaces for reference, we consider the smoother surfaces better conform to ground-truth cases. The reported values on these two metrics are averaged over 100 randomly synthesized 3D meshes. Quantitative comparisons in Table 3 demonstrate our method GOF can preserve better geometry properties.
+
+![](images/c20bafb595ef5d7fa5bc4c0af2f9acc0c1208d6bb2c6dfcbecdce20dd989e116.jpg)
+
+![](images/fe2f6263b603daba3a83f200e962cbc2b4ca2663d8e455e97bf4bdbe003bba8b.jpg)  
+Figure 5: Rendering with only surface points. Images (right) rendered only with surface points are indistinguishable from those (left) obtained with cumulative rendering.   
+Figure 6: Qualitative ablation on proposed priors (upper row w/o $\mathcal { L } _ { \mathrm { o p a c i t y } }$ , bottom row w/o $\mathcal { L } _ { \mathrm { { n o r m a l } } }$ ).
+
+Rendering only with surface points. As mentioned in Sec. 3.2, GOF is able to render an image using only the surface points. To verify this, we showcase in Fig. 5 images rendered by GOF using multiple points and only the surface point. As can be observed, images synthesized with these two strategies are nearly indistinguishable from each other. Thus, GOF possesses the potential to significantly reduce the number of generator queries when synthesizing an image. To compare the efficiency straightforwardly, we estimate the rendering speed of $2 5 6 \times 2 5 6$ images for both pi-GAN and GOF on a single Intel Xeon(R) CPU. On average, pi-GAN costs about 78s per image, while GOF takes about 56s, saving approximately $2 8 \%$ of the time. Owing to the reduction in the burden of queries, GOF enables a light rendering scheme that is promising for applications on mobile devices.
+
+Ablation studies. We here analyze the effects of the proposed regularizations ${ \mathcal { L } } _ { \mathrm { n o r m a l } }$ and $\mathcal { L } _ { \mathrm { o p a c i t y } }$ Table 1 includes the quantitative ablation study on these priors. We also include qualitative samples in Fig. 6, which contains images synthesized by GOF without one regularization item. As shown in the BFM cases 6(a), removing opacity prior leads to the smoke-like artifacts around the cheek part and the absence of normal regularization might degrade the quality of learned normal maps. While testing on the real-world dataset 6(b), undesirable specular highlights emerge on the face and the hollows appear on the corresponding shapes if without the normal regularization. Moreover, we observe that removing opacity prior on CelebA dataset will make the face surfaces too flat and unnatural. It is worth noting that although the performance of GOF is deteriorated due to the absence of these priors, images and surfaces produced by GOF are still of reasonable quality when compared to that from previous approaches, indicating the transition from radiance fields to occupancy fields is the main cause that leads to the success of GOF. Moreover, we showcase the degenerated results on BFM dataset if our model is trained without the shrinking process. As illustrated in Fig. 7, despite the realistic generated images, there emerges random noise on the corresponding normal maps and some nasty dents appear on the face shapes, which demonstrates that the combination of our proposed occupancy representation and the shrinking sampling procedure ensures the surface compactness.
+
+![](images/2e63847e62eb4fcb42c3cea2912d095c6950567cf2c7548ca11ad33ff7ab0e8b.jpg)  
+Figure 7: GOF results without the shrinking process. Noise emerges on normals and dents appear on shapes.
+
+![](images/a907662b559911063e7819033757f9a4f74bf1aa539a5f3860dc58fe58fbe1cb.jpg)  
+Figure 8: GAN inversion results on real images. GOF can reconstruct the target images and simultaneously learn the corresponding normal maps as well as 3D shapes.
+
+![](images/c31620b9ba6ed83b55c6864d7ece026799eb5f6d372621310c845f2aada1e1c8.jpg)  
+Figure 9: Relighting results. Our method GOF generates desirable images under various light conditions while baseline results are far from satisfactory.
+
+Inverse rendering. Through GAN inversion, our method is also capable of inverse rendering as shown in Fig. 8. Given a real image, GOF can reconstruct the target image successfully and realize free view synthesis by controlling the viewpoints. Besides, the recovered normal maps as well as 3D shapes pave the way for downstream tasks such as relighting and editing.
+
+Relighting. In Fig. 9 we provide the relighting results based on the learned normal maps by explicitly controlling the lighting directions. As our method and baselines can’t predict the corresponding albedo, the face-forwarding image is considered as the pseudo albedo. Thanks to better learned normal maps, our method GOF presents promising images under different light conditions. In contrast to ours, baseline methods like pi-GAN [6] tend to generate messy normal maps with obvious checkerboard-like artifacts, leading to noisy and dissatisfied relighting results.
+
+Limitations. While training on real-world datasets, our method GOF might present similar dents in the hair regions as in existing approaches [6]. Besides, the adopted FiLMed-SIREN backbone in the generator will lead to stripe artifacts in the generated images especially when they are rendered only with surface points. Meanwhile, surface rendering mode will make furry cat images over-smooth and less realistic. Moreover, our method is more suitable for solid objects with only one surface.
+
+# 5 Conclusion
+
+In this work, we propose generative occupancy fields (GOF), a novel generative radiance fields for 3D-aware image synthesis. The crux of GOF is a dedicated transition from the cumulative rendering in radiance fields to rendering with only the surface points. Such a transition is inspired by the resemblance between the alpha values in radiance fields and the occupancy values in occupancy networks, so that we can reinterpret one as the other. In practice, such a transition is achieved during training by gradually shrinking the sampling region in the rendering process of GOF from the entire volume to a minimal neighboring region around the surface, where the surface is located via rootfinding on predicted alpha values. Thanks to the transition, surfaces learned by GOF continuously converge during the training, ensuring their compactness at the end. On three diverse datasets, GOF is shown to demonstrate great superiority in synthesizing 3D consistent images and in the meantime capturing compact surfaces, significantly broadening the application of generative radiance fields in downstream tasks.
+
+# Acknowlegements
+
+We would like to thank Eric R. Chan for sharing the codebase of pi-GAN. This work is supported by the Collaborative Research Grant from SenseTime (CUHK Agreement No. TS1712093), the General Research Fund (GRF) of Hong Kong (No. 14205719), the RIE2020 Industry Alignment Fund – Industry Collaboration Projects (IAF-ICP) Funding Initiative, as well as cash and in-kind contribution from the industry partner(s).
+
+# References
+
+[1] I. J. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair, A. C. Courville, and Y. Bengio, “Generative adversarial nets,” in NIPS, 2014.   
+[2] A. Brock, J. Donahue, and K. Simonyan, “Large scale gan training for high fidelity natural image synthesis,” in International Conference on Learning Representations, 2018.   
+[3] T. Karras, S. Laine, and T. Aila, “A style-based generator architecture for generative adversarial networks,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 4401–4410, 2019.   
+[4] T. Karras, S. Laine, M. Aittala, J. Hellsten, J. Lehtinen, and T. Aila, “Analyzing and improving the image quality of stylegan,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 8110–8119, 2020.   
+[5] B. Mildenhall, P. P. Srinivasan, M. Tancik, J. T. Barron, R. Ramamoorthi, and R. Ng, “Nerf: Representing scenes as neural radiance fields for view synthesis,” in ECCV, pp. 405–421, Springer, 2020.   
+[6] E. R. Chan, M. Monteiro, P. Kellnhofer, J. Wu, and G. Wetzstein, “pi-gan: Periodic implicit generative adversarial networks for 3d-aware image synthesis,” in CVPR, 2021.   
+[7] K. Schwarz, Y. Liao, M. Niemeyer, and A. Geiger, “Graf: Generative radiance fields for 3d-aware image synthesis,” in NeurIPS, vol. 33, 2020.   
+[8] L. Mescheder, M. Oechsle, M. Niemeyer, S. Nowozin, and A. Geiger, “Occupancy networks: Learning 3d reconstruction in function space,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 4460–4470, 2019.   
+[9] L. Yariv, Y. Kasten, D. Moran, M. Galun, M. Atzmon, B. Ronen, and Y. Lipman, “Multiview neural surface reconstruction by disentangling geometry and appearance,” Advances in Neural Information Processing Systems, vol. 33, 2020.   
+[10] M. Oechsle, S. Peng, and A. Geiger, “Unisurf: Unifying neural implicit surfaces and radiance fields for multi-view reconstruction,” arXiv preprint arXiv:2104.10078, 2021.   
+[11] M. Niemeyer, L. Mescheder, M. Oechsle, and A. Geiger, “Differentiable volumetric rendering: Learning implicit 3d representations without 3d supervision,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 3504–3515, 2020.   
+[12] Y. Jiang, D. Ji, Z. Han, and M. Zwicker, “Sdfdiff: Differentiable rendering of signed distance fields for 3d shape optimization,” in The IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2020.   
+[13] S. Liu, Y. Zhang, S. Peng, B. Shi, M. Pollefeys, and Z. Cui, “Dist: Rendering deep implicit signed distance function with differentiable sphere tracing,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 2019–2028, 2020.   
+[14] J. J. Park, P. Florence, J. Straub, R. Newcombe, and S. Lovegrove, “Deepsdf: Learning continuous signed distance functions for shape representation,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 165–174, 2019.   
+[15] Z. Chen and H. Zhang, “Learning implicit fields for generative shape modeling,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 5939–5948, 2019.   
+[16] K. Genova, F. Cole, D. Vlasic, A. Sarna, W. T. Freeman, and T. Funkhouser, “Learning shape templates with structured implicit functions,” in Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 7154–7164, 2019.   
+[17] M. Michalkiewicz, J. K. Pontes, D. Jack, M. Baktashmotlagh, and A. Eriksson, “Implicit surface representations as layers in neural networks,” in Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 4743–4752, 2019.   
+[18] S. Saito, Z. Huang, R. Natsume, S. Morishima, A. Kanazawa, and H. Li, “Pifu: Pixel-aligned implicit function for high-resolution clothed human digitization,” in Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 2304–2314, 2019.   
+[19] S. Saito, T. Simon, J. Saragih, and H. Joo, “Pifuhd: Multi-level pixel-aligned implicit function for high-resolution 3d human digitization,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 84–93, 2020.   
+[20] V. Sitzmann, E. R. Chan, R. Tucker, N. Snavely, and G. Wetzstein, “Metasdf: Meta-learning signed distance functions,” arXiv preprint arXiv:2006.09662, 2020.   
+[21] V. Sitzmann, M. Zollhöfer, and G. Wetzstein, “Scene representation networks: Continuous 3d-structure-aware neural scene representations,” in Advances in Neural Information Processing Systems, 2019.   
+[22] L. Liu, J. Gu, K. Z. Lin, T.-S. Chua, and C. Theobalt, “Neural sparse voxel fields,” arXiv preprint arXiv:2007.11571, 2020.   
+[23] A. Yu, R. Li, M. Tancik, H. Li, R. Ng, and A. Kanazawa, “Plenoctrees for real-time rendering of neural radiance fields,” arXiv preprint arXiv:2103.14024, 2021.   
+[24] T. Neff, P. Stadlbauer, M. Parger, A. Kurz, J. H. Mueller, C. R. A. Chaitanya, A. Kaplanyan, and M. Steinberger, “Donerf: Towards real-time rendering of compact neural radiance fields using depth oracle networks,” arXiv preprint arXiv:2103.03231, 2021.   
+[25] P. Hedman, P. P. Srinivasan, B. Mildenhall, J. T. Barron, and P. Debevec, “Baking neural radiance fields for real-time view synthesis,” arXiv preprint arXiv:2103.14645, 2021.   
+[26] M. Boss, R. Braun, V. Jampani, J. T. Barron, C. Liu, and H. Lensch, “Nerd: Neural reflectance decomposition from image collections,” arXiv preprint arXiv:2012.03918, 2020.   
+[27] P. P. Srinivasan, B. Deng, X. Zhang, M. Tancik, B. Mildenhall, and J. T. Barron, “Nerv: Neural reflectance and visibility fields for relighting and view synthesis,” arXiv preprint arXiv:2012.03927, 2020.   
+[28] M. Atzmon, N. Haim, L. Yariv, O. Israelov, H. Maron, and Y. Lipman, “Controlling neural level sets,” arXiv preprint arXiv:1905.11911, 2019.   
+[29] P. Kellnhofer, L. C. Jebe, A. Jones, R. Spicer, K. Pulli, and G. Wetzstein, “Neural lumigraph rendering,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 4287–4297, 2021.   
+[30] J. Wu, C. Zhang, T. Xue, B. Freeman, and J. Tenenbaum, “Learning a probabilistic latent space of object shapes via 3d generative-adversarial modeling,” in NIPS, 2016.   
+[31] X. Chen, D. Cohen-Or, B. Chen, and N. J. Mitra, “Towards a neural graphics pipeline for controllable image generation,” Computer Graphics Forum, vol. 40, no. 2, 2021.   
+[32] J.-Y. Zhu, Z. Zhang, C. Zhang, J. Wu, A. Torralba, J. Tenenbaum, and B. Freeman, “Visual object networks: Image generation with disentangled 3d representations,” in NeurIPS, 2018.   
+[33] Y. Liao, K. Schwarz, L. Mescheder, and A. Geiger, “Towards unsupervised learning of generative models for 3d controllable image synthesis,” in CVPR, pp. 5871–5880, 2020.   
+[34] T. Nguyen-Phuoc, C. Richardt, L. Mai, Y.-L. Yang, and N. Mitra, “Blockgan: Learning 3d object-aware scene representations from unlabelled images,” in Advances in Neural Information Processing Systems 33, Nov 2020.   
+[35] T. Nguyen-Phuoc, C. Li, L. Theis, C. Richardt, and Y.-L. Yang, “Hologan: Unsupervised learning of 3d representations from natural images,” in ICCV, pp. 7588–7597, 2019.   
+[36] M. Niemeyer and A. Geiger, “Giraffe: Representing scenes as compositional generative neural feature fields,” in CVPR, 2021.   
+[37] S. Wu, C. Rupprecht, and A. Vedaldi, “Unsupervised learning of probably symmetric deformable 3d objects from images in the wild,” in CVPR, 2020.   
+[38] X. Pan, B. Dai, Z. Liu, C. C. Loy, and P. Luo, “Do 2d gans know 3d shape? unsupervised 3d shape reconstruction from 2d image gans,” in ICLR, 2021.   
+[39] M. Sahasrabudhe, Z. Shu, E. Bartrum, R. Alp Guler, D. Samaras, and I. Kokkinos, “Lifting autoencoders: Unsupervised learning of a fully-disentangled 3d morphable model using deep non-rigid structure from motion,” in ICCV Workshops, pp. 0–0, 2019.   
+[40] X. Li, S. Liu, K. Kim, S. De Mello, V. Jampani, M.-H. Yang, and J. Kautz, “Self-supervised single-view 3d reconstruction via semantic consistency,” ECCV, 2020.   
+[41] P. Wang, L. Liu, Y. Liu, C. Theobalt, T. Komura, and W. Wang, “Neus: Learning neural implicit surfaces by volume rendering for multi-view reconstruction,” arXiv preprint arXiv:2106.10689, 2021.   
+[42] L. Yariv, J. Gu, Y. Kasten, and Y. Lipman, “Volume rendering of neural implicit surfaces,” arXiv preprint arXiv:2106.12052, 2021.   
+[43] J. T. Kajiya and B. P. Von Herzen, “Ray tracing volume densities,” ACM SIGGRAPH computer graphics, vol. 18, no. 3, pp. 165–174, 1984.   
+[44] Z. Liu, P. Luo, X. Wang, and X. Tang, “Deep learning face attributes in the wild,” in ICCV, pp. 3730–3738, 2015.   
+[45] P. Paysan, R. Knothe, B. Amberg, S. Romdhani, and T. Vetter, “A 3d face model for pose and illumination invariant face recognition,” in 2009 Sixth IEEE International Conference on Advanced Video and Signal Based Surveillance, pp. 296–301, Ieee, 2009.   
+[46] W. Zhang, J. Sun, and X. Tang, “Cat head detection-how to effectively exploit shape and texture features,” in ECCV, pp. 802–816, Springer, 2008.

parse/train/tHzvH4Rv1Qa/tHzvH4Rv1Qa_content_list.json

@@ -0,0 +1,1025 @@
+[
+    {
+        "type": "text",
+        "text": "Generative Occupancy Fields for 3D Surface-Aware Image Synthesis ",
+        "text_level": 1,
+        "bbox": [
+            187,
+            122,
+            813,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Xudong $\\mathbf { X } \\mathbf { u } ^ { \\dag }$ Xingang Pan‡ Dahua Lin† Bo Dai§ †CUHK - SenseTime Joint Lab, The Chinese University of Hong Kong   \n‡Max Planck Institute for Informatics $^ { \\ S } S$ - Lab, Nanyang Technological University   \n$^ \\dag \\{ \\tt x x 0 1 8$ , dhlin}@ie.cuhk.edu.hk ‡xpan@mpi-inf.mpg.de §bo.dai@ntu.edu.sg ",
+        "bbox": [
+            223,
+            224,
+            774,
+            285
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            319,
+            535,
+            337
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The advent of generative radiance fields has significantly promoted the development of 3D-aware image synthesis. The cumulative rendering process in radiance fields makes training these generative models much easier since gradients are distributed over the entire volume, but leads to diffused object surfaces. In the meantime, compared to radiance fields occupancy representations could inherently ensure deterministic surfaces. However, if we directly apply occupancy representations to generative models, during training they will only receive sparse gradients located on object surfaces and eventually suffer from the convergence problem. In this paper, we propose Generative Occupancy Fields (GOF), a novel model based on generative radiance fields that can learn compact object surfaces without impeding its training convergence. The key insight of GOF is a dedicated transition from the cumulative rendering in radiance fields to rendering with only the surface points as the learned surface gets more and more accurate. In this way, GOF combines the merits of two representations in a unified framework. In practice, the training-time transition of start from radiance fields and march to occupancy representations is achieved in GOF by gradually shrinking the sampling region in its rendering process from the entire volume to a minimal neighboring region around the surface. Through comprehensive experiments on multiple datasets, we demonstrate that GOF can synthesize high-quality images with 3D consistency and simultaneously learn compact and smooth object surfaces. Our code is available at https://github.com/SheldonTsui/GOF_NeurIPS2021. ",
+        "bbox": [
+            233,
+            352,
+            766,
+            641
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            667,
+            312,
+            685
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep generative adversarial networks [1–4] have demonstrated their superiority in synthesizing photorealistic and striking images. However, these models are often constrained in the 2D domain, struggling to generate 3D consistent images, let alone grasping the underlying 3D object shapes. 3D-aware image synthesis thus becomes an appealing and promising choice as it learns a 3D representation explicitly from a collection of unposed images. Consequently, it can not only synthesize 3D consistent images by manually controlling the rendering camera poses, but also pave the way for various downstream tasks such as shape editing and relighting. ",
+        "bbox": [
+            174,
+            699,
+            825,
+            797
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Inspired by the success of neural radiance fields (NeRF) [5] in 3D scene modeling, recent 3D-aware generative models, referred to as generative radiance fields (GRAFs), have applied NeRF as the explicit 3D representation for image synthesis [6, 7]. With the help of NeRF, they are capable of hallucinating photorealistic images in a 3D consistent manner. Moreover, since NeRF holds the superior ability for rendering translucent objects by compositing colored densities along each ray in its volume rendering process, it also significantly facilitates the training of GRAFs as gradients are naturally distributed over the entire volume. However, they still incur an inevitable incapacity of capturing an accurate and compact object surface. As shown in Fig. 1(a), the state-of-the-art GRAF model pi-GAN is prone to predict diffused object surfaces, as the volume densities are smoothly spread around the surfaces. Such diffused surfaces could significantly hamper the applications of GRAF models in downstream tasks such as shape recovery. Moreover, under different light conditions, the artifacts of surfaces could be amplified and inherited through the rendering process, resulting in synthesized images that are messy and faulty. ",
+        "bbox": [
+            174,
+            803,
+            825,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/8e4cfc63bb10b58b927f5606b09142659b4d5b7e80778cc5cc03f1ee4f7ac8b7.jpg",
+        "image_caption": [
+            "Figure 1: (a) The cumulative rendering weights (color weights) of our approach GOF more focus on the surface (y-axis) than previous methods like pi-GAN [6], which indicates our predicted volume densities more concentrate on the object surfaces. (b) Owing to the diffused volume densities, the preceding method pi-GAN captures messy surface normals and object shapes. Moreover, the image rendered only with the surface points is quite noisy. In contrast, more surface-centralized densities predicted by our method ensure compact and smooth object surfaces thus enable a high-quality surface rendering during inference. (Zoom in for best view) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            101,
+            815,
+            268
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            387,
+            825,
+            470
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we propose Generative Occupancy Fields (GOF), a novel GRAF-like image synthesis model that can learn compact object surfaces. GOF is inspired by the design of occupancy networks [8] that implicitly represents a 3D surface with the continuous decision boundary of a neural classifier. In this way, occupancy networks are capable of effectively locating surfaces via root-finding and encouraging the compactness of modeled surfaces inherently. However, GOF avoids directly applying such a design to 3D-aware image synthesis. While occupancy networks require precise object masks to train [9, 10], a more crucial factor is that they rely on the surface points for differentiable rendering [11, 12, 9, 13]. A generative model equipped with occupancy representations will thus meet severe convergence problems during training due to the sparsity of gradients. To unify the merits of both NeRF and occupancy networks for 3D-aware image synthesis, GOF adopts the design of GRAFs and at the same time leverages a nontrivial transition from the cumulative rendering to rendering with only the surface points, i.e. start from radiance fields and march to occupancy representations. Specifically, GOF will reinterpret the alpha values in the cumulative rendering process as occupancy values, so that it can locate the learned surface via root-finding. Subsequently, it can naturally encourage the compactness of learned surfaces by gradually shrinking the sampling region in the rendering process from the entire volume to a minimal neighboring region around the surface. ",
+        "bbox": [
+            174,
+            477,
+            825,
+            710
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Thanks to the unified integration of radiance fields and occupancy representations, GOF can benefit from the representation effectiveness of radiance fields while ensuring the compactness of learned object surfaces through the shrinking process. As presented in Fig. 1(a), in GOF the distribution of cumulative rendering weights concentrates more closely around object surfaces compared to that of pi-GAN, eventually resulting in a compact and smooth surface. Moreover, GOF can thus alternatively render an image only with points on the learned surfaces like occupancy networks as illustrated in Fig. 1 (b). And during inference such a rendering scheme has the potential to alleviate the burden of sampling a large number of points along each ray for synthesizing a single image. Through exhaustive experiments on synthetic and real-world datasets, we demonstrate that GOF can achieve state-of-the-art performance on 3D-aware image synthesis. Meanwhile, it is capable of capturing compact and accurate 3D shapes that empower its applications in various downstream tasks such as 3D shape reconstruction. We validate this point by quantitative results of 3D shape reconstruction on the Synface dataset. Finally, we have also verified the ability of GOF in rendering high-quality images with only the surface points, which is hardly achievable in previous approaches. ",
+        "bbox": [
+            174,
+            718,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            321,
+            106
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Neural implicit function for 3D representations. A plethora of works [14, 8, 15–21] has exploited neural implicit functions for 3D geometry modeling. Among these works, neural radiance fields (NeRF) [5] has attracted growing attention due to its compelling results on novel view synthesis. It leverages an MLP network to approximate the radiance fields of static 3D scenes. And by learning to reconstruct existing views, it is capable of capturing 3D geometric details from only 2D supervision. A series of succeeding variants of NeRF have been proposed to improve it, including utilizing the spatial sparsity to reduce its computational complexity [22, 23], refining the rendering process to improve its efficiency [24, 25], as well as adopting reflectance decompositions to enhance its modeling capacity [26, 27]. There are also works that capitalize on the differentiable rendering of neural implicit functions for 3D reconstruction [11, 12, 9, 13, 28, 29]. Specifically, SDFDiff [12] relies on the interpolation of eight neighboring SDF samples around the surface intersection to obtain the derivatives, while Atzmon et al [28] use a sample network to relate samples’ positions to network parameters and thus achieve an improved generalization ability. More interestingly, by adopting occupancy representations, DVR [11] and IDR [9] show volumetric rendering is inherently differentiable so that network parameters can be optimized directly with derived analytic gradients. Different from methods aforementioned above, GOF is a generative model for 3D-aware image synthesis that can learn 3D representations from a set of 2D images with unknown camera poses. ",
+        "bbox": [
+            174,
+            119,
+            825,
+            354
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Generative 3D-aware image synthesis. In order to synthesize 3D consistent images, researchers have explored a lot on how to incorporate 3D representations into the classical GAN model [1]. Some methods [30–32] resort to learning from 3D data directly, yet the requirement of 3D supervision limits their practical applicability. A more appealing alternative is thus learn from unposed 2D images in an unsupervised manner. Preceding works along this line of research adopt voxels as their intermediate 3D representations [33–35] and achieve explicit control over the pose of synthesized images. Inspired by the superior representation capacity of radiance fields over voxels, recent attempts [6, 7, 36] have replaced voxels with neural radiance fields [5] to improve the fidelity of synthesized 3D consistent images. Despite the striking performance, these models, referred to as generative radiance fields (GRAFs), tend to predict diffused object surfaces, which impedes its applicability in various downstream tasks. In this work, GOF aims at resolving this problem of GRAFs by combining them with the perspective of occupancy networks [8] and recent successes of recovering smooth and accurate shapes from natural images [37–40]. Recently, three concurrent works, UNISURF [10], NeuS [41] and VolSDF [42], also combine implicit surfaces and radiance fields in a unified framework, sharing similar spirits with our proposed GOF but different in tasks and focuses. Specifically, They focus on multi-view 3D reconstruction and attempt to alleviate the requirement of training-time precise masks through the integration of radiance fields and occupancy representations. Nevertheless, they still require images with ground-truth poses for training. By contrast, GOF targets on the challenging task of 3D-aware image synthesis, where the synthesized images should be not only natural and vivid, but also consistent in the 3D space. By integrating radiance fields and occupancy representations, GOF is able to facilitate the convergence of GRAFs and ensure the compactness of learned object surfaces. Compared to existing GRAFs, the applicability of GOF is thus significantly broadened. ",
+        "bbox": [
+            174,
+            362,
+            825,
+            679
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Methodology ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            699,
+            313,
+            715
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We propose generative occupancy fields (GOF), a novel synthesis model, belonging to generative radiance fields and aiming to learn from unposed images. Conditioned on a latent code $\\mathbf { z } \\sim p _ { \\mathbf { z } }$ , our generator $g _ { \\theta }$ can generate a 3D radiance field $\\mathbf { R }$ , from which we can render a realistic image with a sampled camera pose $\\xi \\sim p _ { \\xi }$ and simultaneously recover smooth and compact object surfaces. In the following, we first present the background of neural radiance fields, and then introduce our proposed GOF model in detail. ",
+        "bbox": [
+            174,
+            729,
+            825,
+            813
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Neural Radiance Fields ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            829,
+            375,
+            844
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We adopt neural radiance fields (NeRF) as our explicit 3D representation for image synthesis, owing to its strong performance in novel view synthesis on complex scenes. NeRF represents a static scene as per-point volume densities and view-dependent RGB colors. Given a 3D point $\\mathbf { x } \\in \\mathbb { R } ^ { 3 }$ in space and a view direction $\\mathbf { d } \\in \\mathbb { R } ^ { 3 }$ , NeRF capitalizes on a multi-layer perceptron (MLP) to predict the volume density $\\sigma ( \\mathbf { x } ) \\in \\mathbb { R }$ and the emitted color $\\mathbf { c } ( \\mathbf { x } , \\mathbf { d } ) \\in \\mathbb { R } ^ { 3 }$ . To render a novel view for the scene, NeRF leverages the classic volume rendering technique [43] to estimate the color of each pixel. It starts by accumulating the colored densities of $N$ points $\\left\\{ { \\bf x } _ { i } = { \\bf o } + t _ { i } { \\bf d } \\right\\}$ sampled within near and far bounds $[ t _ { n } , t _ { f } ]$ along the camera ray $\\mathbf { r } ( t ) = \\mathbf { o } \\overset { \\cdot } { + } t \\mathbf { d }$ , where $\\mathbf { o }$ stands for the camera origin. The integrated color is then estimated via alpha composition as follows: ",
+        "bbox": [
+            174,
+            856,
+            823,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/bd983df8c4534842b7ff7b61a0d089ed1c071f2c9a46de2898073258adf48897.jpg",
+        "image_caption": [
+            "Figure 2: Shrinking process. During the training, the sampling interval $\\Delta$ is initially a half of the distance between near $t _ { n }$ and far bounds $t _ { f }$ and shrinks gradually to a pre-defined value $\\Delta _ { \\mathrm { m i n } }$ . For inference, we can use cumulative rendering by sampling points in the minimal interval $\\Delta _ { \\mathrm { m i n } }$ and alternatively render only with the surface points. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            95,
+            818,
+            270
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            368,
+            823,
+            439
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ab8a0834b245eeae09ef29e0a4f601743a52e4e59d199a8cfba9da7e8dcad62f.jpg",
+        "text": "$$\n\\hat { \\mathbf { C } } ( \\mathbf { r } ) = \\sum _ { i = 1 } ^ { N } T _ { i } \\Big ( 1 - \\exp \\big ( - \\sigma ( \\mathbf { x } _ { i } ) \\delta _ { i } \\big ) \\Big ) \\mathbf { c } ( \\mathbf { x } _ { i } , \\mathbf { d } ) , \\mathrm { ~ w h e r e ~ } T _ { i } = \\exp ( - \\sum _ { j = 1 } ^ { i - 1 } \\sigma ( \\mathbf { x } _ { j } ) \\delta _ { j } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            225,
+            446,
+            769,
+            492
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\delta _ { i } = | x _ { i + 1 } - x _ { i } |$ is the distance between adjacent points. Note that, equation (1) is naturally differentiable and NeRF can be directly optimized through the reconstruction error of existing views. ",
+        "bbox": [
+            173,
+            501,
+            828,
+            530
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 3D Surface-Aware Image Synthesis via Generative Occupancy Fields ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            546,
+            692,
+            563
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To apply NeRF as the 3D representation, the proposed generative occupancy fields (GOF) incorporates an additional latent code $\\mathbf { z } \\sim p _ { \\mathbf { z } }$ into NeRF, such that synthesizing an image follows a reformulated cumulative rendering process: ",
+        "bbox": [
+            174,
+            573,
+            825,
+            616
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/797b16944b571a44379ac992bef13820c84dd8eba7bfb950fe58d624d64a2a01.jpg",
+        "text": "$$\n\\hat { \\mathbf { C } } ( \\mathbf { r } , \\mathbf { z } ) = \\sum _ { i = 1 } ^ { N } T _ { i } \\Big ( 1 - \\exp \\big ( - \\sigma _ { \\theta } ( \\mathbf { x } _ { i } , \\mathbf { z } ) \\delta _ { i } \\big ) \\Big ) \\mathbf { c } _ { \\theta } \\big ( \\mathbf { x } _ { i } , \\mathbf { d } , \\mathbf { z } \\big ) , \\mathrm { ~ w h e r e ~ } T _ { i } = \\exp \\big ( - \\sum _ { j = 1 } ^ { i - 1 } \\sigma _ { \\theta } ( \\mathbf { x } _ { j } , \\mathbf { z } ) \\delta _ { j } \\big ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            179,
+            622,
+            799,
+            667
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "However, directly training GOF according to Eq.(2) fails to maintain the surface compactness as reported in previous approaches [6, 7]. Actually, such a defect arises from an inevitable “shape-color ambiguity” of the cumulative rendering process, i.e., small perturbations on surfaces still lead to realistic RGB images which are enough to fool the discriminator. ",
+        "bbox": [
+            174,
+            675,
+            825,
+            732
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Owing to the constrained range of poses seen at training, the discriminator is less motivated to further concentrate the color weights $w _ { i } \\bar { = } T _ { i } \\big ( 1 - \\exp ( - \\sigma _ { \\theta } ( \\mathbf { \\bar { x } } _ { i } , \\mathbf { z } ) \\delta _ { i } ) \\big )$ aforementioned in Fig. 1 (a) on the exact object surface. On the other hand, we observe that although leading to diffused surfaces at the end, color weights $w _ { i }$ gradually concentrate around the object surface as the training proceeds. Inspired by this observation, in GOF we propose a training-time operation to facilitate the concentration of color weights $w _ { i }$ . The basic idea is gradually shrinking the sample region in the cumulative rendering process from the entire volume to a narrow interval around the surface, so that color weights are enforced to continuously move towards the exact surface. ",
+        "bbox": [
+            173,
+            738,
+            825,
+            849
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To enable the proposed training-time shrinking process, GOF is required to locate the surface by thresholding the predicted densities $\\sigma _ { \\boldsymbol { \\theta } } ( \\mathbf { x } , \\mathbf { z } )$ , assuming points on the surface have the largest densities, However, values of the densities predicted in generative radiance fields could range from 0 to 50, making it hard to determine an effective threshold $\\tau$ during the whole training period. On the other hand, in the cumulative rendering process shown in Eq.(2), we found that the intermediate alpha values used for numerical stability inherently fall in a fixed value range as: ",
+        "bbox": [
+            174,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e3e38d7a50b0d08cde08486d0fa6b19f2a03bc42974ad1bab492ef2559f5b468.jpg",
+        "text": "$$\n\\alpha _ { \\theta } ( \\mathbf { x } _ { i } , \\mathbf { z } ) = 1 - \\exp ( - \\sigma _ { \\theta } ( \\mathbf { x } _ { i } , \\mathbf { z } ) \\delta _ { i } ) \\in [ 0 , 1 ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            351,
+            127,
+            647,
+            145
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "More importantly, these alpha values $\\alpha _ { \\boldsymbol { \\theta } } ( \\mathbf { x } , \\mathbf { z } )$ come close to 1 for points in the occupied space while approaching 0 for points in the free space, making them resemble the occupancy values [8] in both quantity and semantics. Inspired by the similarity, we thus propose to reformulate generative radiance fields by predicting alpha values $\\alpha _ { \\boldsymbol { \\theta } } ( \\mathbf { x } , \\mathbf { z } )$ directly instead of volume densities $\\sigma _ { \\boldsymbol { \\theta } } \\bar { ( } \\mathbf { x } , \\mathbf { z } )$ . In the mean time, we reinterpret the alpha values as occupancy values, and subsequently locate surfaces with root-finding, a more effective strategy originated in occupancy networks [11]. According to the above reformulation and reinterpretation, we thus dub our method as Generative Occupancy Fields. ",
+        "bbox": [
+            173,
+            151,
+            825,
+            250
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As GOF estimates alpha values instead of volume densities, the original volume rendering process in Eq.(2) conditioned on the latent code $\\mathbf { z }$ is reformulated as ",
+        "bbox": [
+            171,
+            256,
+            823,
+            285
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/82de6dbde825611fb0e4215a901b1bdf49320bdf86d10cbecb3fbd8bad796ffd.jpg",
+        "text": "$$\n\\hat { \\mathbf { C } } ( \\mathbf { r } , \\mathbf { z } ) = \\sum _ { i = 1 } ^ { N } \\alpha _ { \\theta } \\big ( \\mathbf { x } _ { i } , \\mathbf { z } \\big ) \\prod _ { j < i } \\big ( 1 - \\alpha _ { \\theta } \\big ( \\mathbf { x } _ { j } , \\mathbf { z } \\big ) \\big ) \\mathbf { c } _ { \\theta } \\big ( \\mathbf { x } _ { i } , \\mathbf { d } , \\mathbf { z } \\big ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            310,
+            291,
+            686,
+            337
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where the value range of $\\alpha _ { \\theta } ( \\mathbf { x } _ { i } , \\mathbf { z } )$ is guaranteed with a sigmoid function. And to locate the surface via root-finding, for a specific ray $\\dot { \\mathbf { r } } ( t ) = \\mathbf { o } + t \\mathbf { d }$ we will evenly sample $M$ points $\\begin{array} { r } { \\left\\{ \\mathbf { x } _ { k } = \\mathbf { o } + t _ { k } \\mathbf { d } ; k = \\right. } \\end{array}$ $1 , . . . , M \\}$ that partition the entire volume $[ t _ { n } , t _ { f } ]$ into $M$ equally-spaced bins. After obtaining the corresponding alpha values $\\{ \\alpha _ { \\boldsymbol { \\theta } } ( \\mathbf { x } _ { k } , \\mathbf { z } ) ; k \\stackrel { - } { = } 1 , . . . , M \\}$ by querying the generator $g _ { \\theta }$ , the surface $s$ is located in the $k ^ { \\dot { S } }$ -th bin where $\\alpha \\theta$ changes for the first time from free space $( \\alpha _ { \\theta } < \\tau )$ to occupied space $( \\alpha _ { \\theta } < \\tau )$ ): ",
+        "bbox": [
+            173,
+            344,
+            826,
+            428
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f6f7bd69162e3ec7dd1f8f3b6af81a3088e02140fc99cca2b2cfa8fad9a5a2fa.jpg",
+        "text": "$$\nk ^ { S } = \\underset { k } { \\mathrm { a r g m i n } } \\big ( \\alpha _ { \\theta } ( \\mathbf { x } _ { k } , \\mathbf { z } ) < \\tau \\leq \\alpha _ { \\theta } ( \\mathbf { x } _ { k + 1 } , \\mathbf { z } ) \\big ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            428,
+            655,
+            455
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\tau$ is a pre-defined threshold. In practice, we empirically set $\\tau$ as 0.5. In order to find the surface point $\\mathbf { x } _ { s } = \\mathbf { o } + t _ { s } \\mathbf { d }$ more precisely, we further apply the above secant method iteratively for $m _ { s }$ times, resulting in a fine-grained bin $\\left[ \\mathbf { x } _ { k ^ { s } } , \\mathbf { x } _ { k ^ { s } + 1 } \\right]$ . It’s worth noting that the $M$ sampled points are only used for root-finding. Thus they do not require the computation of gradients in the implementation. ",
+        "bbox": [
+            174,
+            459,
+            825,
+            530
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Based on the located surface $s$ , we can thus successfully conduct the proposed shrinking process, which is schematically elaborated in Fig. 2. Specifically, when sampling $N$ points for Eq.(4) at each training step, we will only sample within a region neighboring the surface $[ t _ { s } - \\Delta , t _ { s } + \\Delta ]$ : ",
+        "bbox": [
+            174,
+            535,
+            825,
+            579
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b5ec8f54a9387d9407c3749baf2d8dfb37136abbd48ca5ee34c58c3b0395dced.jpg",
+        "text": "$$\nt _ { i } \\sim \\mathcal { U } \\left[ t _ { s } - \\Delta + \\frac { 2 i - 2 } { N } \\Delta , t _ { s } - \\Delta + \\frac { 2 i } { N } \\Delta \\right] , \\mathrm { w h e r e } i = 1 , 2 , . . . , N .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            269,
+            584,
+            728,
+            621
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$\\Delta$ is the sampling interval, which is set to $\\Delta _ { \\mathrm { i n i t } } = ( t _ { f } - t _ { n } ) / 2$ at the beginning, a half of the distance between near $t _ { n }$ and far bounds $t _ { f }$ . And it will decrease monotonically with an exponential decay rate $\\gamma$ until it drops to a pre-defined minimal value $\\Delta _ { \\mathrm { m i n } }$ . Formally, $\\Delta _ { n } = \\mathrm { m a x } ( \\Delta _ { \\mathrm { i n i t } } \\exp ( - \\gamma n ) , \\Delta _ { \\mathrm { m i n } } )$ for $n$ -th decaying step. Additionally, during training when the estimated $t _ { s }$ is too close to the near or the far bound so that the sampling region $[ t _ { s } - \\Delta , t _ { s } + \\Delta ]$ exceeds the original range $[ t _ { n } , t _ { f } ]$ , we will shift the region $[ t _ { s } - \\Delta , t _ { s } + \\Delta ]$ back to within $[ t _ { n } , t _ { f } ]$ . As shown in Fig. 2, at the beginning of training, points sampled for Eq.(4) will cover the entire volume, leading to dispersed gradients which facilitate the convergence of GOF. And as the training goes, the predicted surface will become more and more accurate, which is the outcome of gradually refining the sampling region, and in turn also makes the above shrinking operation valid. ",
+        "bbox": [
+            173,
+            627,
+            825,
+            767
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Thanks to the dedicated shrinking process, the color weights $w _ { i }$ can successfully concentrate on the object surface as illustrated in Fig. 1(a). As a result, GOF is capable of synthesizing highfidelity images in a 3D-consistent manner and simultaneously capturing compact object surfaces. During inference, to synthesize an image under a random camera pose $\\xi \\sim p _ { \\xi }$ , the generator $g _ { \\boldsymbol { \\theta } }$ will fetch a truncated latent code $\\hat { \\mathbf { z } }$ and sample $N$ points $\\{ { \\bf { x } } _ { i } \\}$ on each ray within the minimal region $[ t _ { s } - \\Delta _ { \\mathrm { m i n } } , t _ { s } + \\Delta _ { \\mathrm { m i n } } ]$ for the rendering as in Eq.(4). An important benefit of learning a compact object surface is that we can effectively reduce the number of sampled points for rendering, even using only one point on each ray, i.e. the surface point. As shown in Fig. 1 (b), the image rendered with only the surface point is almost indistinguishable from that with multiple points. Such equivalence can be guaranteed theoretically when $\\Delta _ { \\operatorname* { m i n } }  0$ , and we include the proof in the supplementary material. ",
+        "bbox": [
+            173,
+            772,
+            826,
+            912
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 Loss Functions ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            90,
+            318,
+            106
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Instead of training on posed 2D images, the proposed GOF leverages a corpus of unposed images for 3D-aware image synthesis, where multiple loss functions are adopted. ",
+        "bbox": [
+            173,
+            116,
+            823,
+            145
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "GAN Loss. Following pi-GAN [6], a GAN loss is used where GOF synthesizes fake images by randomly sampling camera poses $\\xi$ from a dataset-related distribution $p _ { \\xi }$ and rendering according to Eq.(4). Denote $I$ as a real image from the data distribution $p _ { \\mathcal { D } }$ , the non-saturating GAN loss can be described as follows: ",
+        "bbox": [
+            174,
+            150,
+            825,
+            205
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/545d70e8373b5e4adee054dc9cc78b49164dec8b128b090fcb011b837baf5916.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathcal { L } _ { \\mathrm { o r i g i n } } ( \\theta _ { D } , \\theta _ { G } ) = { \\bf E } _ { { \\bf z } \\sim p _ { \\bf z } , \\xi \\sim p _ { \\xi } } \\left[ f \\Big ( D _ { \\theta _ { D } } ( G _ { \\theta _ { G } } ( { \\bf z } , \\xi ) ) \\Big ) \\right] } \\\\ & { \\quad \\quad \\quad \\quad \\quad + { \\bf E } _ { I \\sim p _ { \\mathcal D } } \\left[ f ( - D _ { \\theta _ { D } } ( I ) ) + \\lambda | \\nabla D _ { \\theta _ { D } } ( I ) | ^ { 2 } \\right] , } \\\\ & { \\quad \\quad \\quad \\quad \\quad \\mathrm { w h e r e ~ } f ( u ) = - \\log ( 1 + \\exp ( - u ) ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            208,
+            694,
+            273
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "However, $\\mathcal { L } _ { \\mathrm { o r i g i n } }$ alone is not sufficient to guide the training, which may lead to messy images with smoke-like artifacts. Therefore, two more regularizations are incorporated to reduce artifacts and further smooth the learned surfaces. ",
+        "bbox": [
+            176,
+            277,
+            823,
+            319
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Normal Regularization. The first regularization is a prior on the surface normal smoothness, which is specially useful for learning from 2D real-world images [11]. In GOF, this normal prior is only employed for the surface points $\\mathbf { x } _ { s } \\in \\mathcal { S }$ to encourage a natural and smooth surface: ",
+        "bbox": [
+            173,
+            325,
+            825,
+            368
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/24dba99d571f7c03138eeb76877eb5e04b4efe0ff73d4bb1d6b3dc94612c3f5b.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { n o r m a l } } = \\sum _ { \\mathbf { x } _ { s } \\in \\mathcal { S } } | | \\mathbf { n } _ { \\theta } ( \\mathbf { x } _ { s } , \\mathbf { z } ) - \\mathbf { n } _ { \\theta } ( \\mathbf { x } _ { s } + \\epsilon , \\mathbf { z } ) | | _ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            344,
+            372,
+            651,
+            406
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\epsilon$ is a small random 3D perturbation and $\\mathbf { n } _ { \\theta }$ denotes the normal vector, which can be computed by $\\begin{array} { r } { \\mathbf { n } _ { \\theta } ( \\mathbf { x } , \\mathbf { z } ) = \\nabla _ { \\mathbf { x } } \\alpha _ { \\theta } ( \\mathbf { x } , \\mathbf { z } ) / | | \\mathcal { \\bar { \\nabla } } _ { \\mathbf { x } } \\alpha _ { \\theta } ( \\mathbf { x } , \\mathbf { z } ) | | _ { 2 } } \\end{array}$ . ",
+        "bbox": [
+            174,
+            410,
+            823,
+            440
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Opacity Regularization. Since alpha values predicted in GOF can be regarded as occupancy values, ideally the entropy of them should be 0 so that $\\alpha _ { \\boldsymbol { \\theta } } ( \\mathbf { x } , \\mathbf { z } )$ values will equal 1 for points in the occupied space and 0 for points in the free space. We thus apply the second opacity regularization, aiming to reduce the entropy of predicted alpha values: ",
+        "bbox": [
+            173,
+            444,
+            825,
+            501
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/45a1b647c4cb2cfd8eb04484ac4ea99db82a96bff5e166c4cac839c09bf2e962.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { o p a c i t y } } = \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } \\log ( \\alpha _ { \\theta } ( \\mathbf { x } _ { i } , \\mathbf { z } ) ) + \\log ( 1 - \\alpha _ { \\theta } ( \\mathbf { x } _ { i } , \\mathbf { z } ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            316,
+            505,
+            679,
+            549
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In summary, the final loss function for training GOF can be written as: ",
+        "bbox": [
+            169,
+            558,
+            635,
+            573
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3e66c2651a2167effc62feed5e7f4cbd580101a86fe54dfc54faae2366bc4498.jpg",
+        "text": "$$\n\\mathcal { L } ( \\theta , \\phi ) = \\mathcal { L } _ { \\mathrm { o r i g i n } } ( \\theta , \\phi ) + \\lambda _ { \\mathrm { n o r m a l } } \\mathcal { L } _ { \\mathrm { n o r m a l } } + \\lambda _ { \\mathrm { o p a c i t y } } \\mathcal { L } _ { \\mathrm { o p a c i t y } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            312,
+            577,
+            684,
+            594
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda _ { \\mathrm { { n o r m a l } } }$ and $\\lambda _ { \\mathrm { o p a c i t y } }$ are both balancing coefficients. ",
+        "bbox": [
+            173,
+            598,
+            544,
+            614
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            632,
+            312,
+            648
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Implementation Details. Unless stated otherwise, in all experiments we set $N$ , the number of points sampled for rendering, to 12, and set $M$ , the number of bins used in root-finding, to 12. As discussed in Sec.3.2, we apply an iterative process in root-finding. In practice, the number of iterations is set to $m _ { s } = 3$ times. During inference, GOF requires $M + m _ { s } + N$ queries to obtain the color of a pixel, while existing methods require $2 N$ queries due to the use of a hierarchical sampling strategy. Recall it is sufficient for GOF to sample only the surface point to render an image, GOF is thus capable of using just $M + m _ { s } + 1$ queries, potentially speeding up the rendering process in off-line applications. More training and implementation details can be found in the supplemental material. ",
+        "bbox": [
+            173,
+            661,
+            826,
+            773
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Datasets. To assess our method comprehensively, we conduct experiments on three datasets, namely CelebA [44], BFM [45], and Cats [46]. Specifically, CelebA is a high-resolution face dataset containing 200, 000 diverse face images. Following pi-GAN [6], we crop all images in CelebA from the top of the hair to the bottom of the chin as a pre-processing step. As for the Cats dataset, it contains 6, 444 cat faces of size $1 2 8 \\times 1 2 8$ . Finally, BFM is a synthetic face dataset rendered with Basel Face Model, where each face is paired with a ground-truth depth map, making it a good benchmark for quantitatively evaluating the quality of learned surfaces. ",
+        "bbox": [
+            173,
+            779,
+            825,
+            877
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Comparison with baselines. To validate the effectiveness of GOF, we compare it with two representative GRAF methods, namely GRAF [7] and pi-GAN. Firstly, Fig. 3 demonstrates the qualitative comparison between these three methods, where we include the synthesized images, the learned surfaces in the form of 3D meshes, as well as the corresponding normal maps. As can be observed, GRAF struggles to render good images, let alone estimate compact and reasonable underlying surfaces. Compared to GRAF, pi-GAN can synthesize images and estimate corresponding surfaces with improved quality. However, messy parts can be clearly recognized on its learned surfaces and normal maps, indicating it is incapable of capturing the compact 3D geometric details. In contrast to both pi-GAN and GRAF, the proposed GOF is shown to hallucinate realistic images with 3D consistency and simultaneously learn smooth surface normals as well as compact object surfaces, which verifies the benefit of adopting the transition from radiance fields to occupancy fields. More qualitative results of synthesized images and corresponding surfaces are included in Fig. 4. ",
+        "bbox": [
+            173,
+            882,
+            823,
+            912
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "",
+        "table_caption": [
+            "Table 1: Quantitative results $( 1 2 8 \\times 1 2 8 \\mathrm { p x } )$ ) on BFM, CelebA and Cats datasets, on three metrics Fréchet Inception Distance (FID), Inception Score (IS) and the weighted variance of sampled depth $\\Sigma _ { t _ { i } } ( \\times 1 0 ^ { - 4 } )$ . "
+        ],
+        "table_footnote": [],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/7cbd855904b7fe282b61597f75dac06c7e87466d77949262c3f765c73762a11b.jpg",
+        "image_caption": [
+            "Figure 3: Qualitative comparison on BFM (top), CelebA (middle), and Cats (bottom) datasets. Our method synthesizes realistic images while ensuring compact object surfaces. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            132,
+            823,
+            777
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/c2686d2f02030b67a30d3cc43f6418532383b3bfd859454cb663a831e12f2c92.jpg",
+        "table_caption": [
+            "Table 2: Comparisons on the compactness and accuracy of learned surfaces. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>SIDE↓</td><td>MAD↓</td></tr><tr><td>Supervised</td><td>0.412</td><td>10.84</td></tr><tr><td>Unsup3d [37]</td><td>0.795</td><td>16.51</td></tr><tr><td>GRAF[7]</td><td>1.866</td><td>26.69</td></tr><tr><td>pi-GAN [6]</td><td>0.727</td><td>20.46</td></tr><tr><td>GAN2Shape [38]</td><td>0.759</td><td>14.94</td></tr><tr><td>Ours</td><td>0.779</td><td>13.81</td></tr></table>",
+        "bbox": [
+            191,
+            132,
+            468,
+            251
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/8dd52bfe0ab61e55da49dfab84a584c1a8b95d0396bf9f9d174f738b6c7eb69a.jpg",
+        "table_caption": [
+            "Table 3: Comparisons on the geometry properties of learned surfaces. We report mean curvature $( \\mathbf { M C } ) ( \\times 1 0 ^ { - 3 } )$ and mean geodesic distance(MGD) between random points to assess the geometry properties of recovered surfaces. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\"></td><td>BFM</td><td>CelebA</td><td>Cats</td></tr><tr><td>MC↓</td><td>pi-GAN Ours</td><td>16.84 12.25</td><td>25.94 23.13</td><td>34.05 30.14</td></tr><tr><td>MGD↓</td><td>pi-GAN Ours</td><td>0.483 0.226</td><td>0.450 0.231</td><td>0.494 0.317</td></tr></table>",
+        "bbox": [
+            504,
+            167,
+            833,
+            257
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/dcca993f4bffe3c3b1f7a9950ad87ce0db78468086b69de1bfce327dbd7d8445.jpg",
+        "image_caption": [
+            "Figure 4: Generated images and their 3D meshes on CelebA and Cats datasets. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            270,
+            816,
+            434
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            468,
+            825,
+            511
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To quantitatively evaluate the quality of generated images, we report the Fréchet Inception Distance (FID) scores and Inception Score (IS) scores in Table 1. On these two metrics, GOF demonstrates substantial improvements over baseline methods. To further measure the compactness of learned surfaces, the concentration of color weights $w _ { i }$ as mentioned in Fig. 1 (a) is also computed. Specifically, We sample $N = 3 6$ equally-spaced points $\\left\\{ { \\bf x } _ { i } = { \\bf o } + t _ { i } { \\bf d } \\right\\}$ within near and far bounds $[ t _ { n } , t _ { f } ]$ and calculate the corresponding color weights $w _ { i } , i = 1 , 2 , . . . , N$ . Actually, the weighted variance of these samples’ depth $t _ { i }$ reflects the concentration of color weights in a single image: ",
+        "bbox": [
+            173,
+            516,
+            825,
+            614
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f6a0af330b6838ce28e8b7e9dc6cf6fc277e89e55e101b28a4b44b80c1f420e0.jpg",
+        "text": "$$\n\\Sigma _ { t _ { i } } = \\frac { N } { ( N - 1 ) \\sum _ { i = 1 } ^ { N } w _ { i } } \\sum _ { i = 1 } ^ { N } w _ { i } ( t _ { i } - \\bar { t } ) ^ { 2 } , \\mathrm { ~ w h e r e ~ } \\bar { t } = \\sum w _ { i } t _ { i } \\Big / \\sum w _ { i } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            248,
+            616,
+            746,
+            654
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, a smaller variance implies the learned surface is more compact. Finally, for each method, the overall concentration of color weights is averaged over 1000 randomly synthesized images at the $2 5 6 \\times 2 5 6$ resolution. The results in terms of this new metric are also included in Table 1. ",
+        "bbox": [
+            174,
+            656,
+            825,
+            698
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For the quality of learned surfaces, we first evaluate the compactness and accuracy of surfaces on the BFM dataset, since it contains ground-truth depth maps. Specifically, $5 0 K$ images are generated by each method, together with their corresponding depth maps. For each method, we train a separate CNN on these generated images and depth maps to predict depths from images. Subsequently, we can measure the accuracy of learned surfaces by running the CNN on the test split of BFM and comparing its outputs to the ground-truth depth maps using the scale-invariant depth error (SIDE) and the mean angle deviation (MAD). While MAD focuses more on the compactness of surfaces, SIDE emphasizes more on the accuracy of depth. As shown in Table 2, GOF significantly outperforms baseline methods on the MAD metric and is comparable to strong baselines on the SIDE metric. Moreover, we also report mean curvature (MC) and mean geodesic distance (MGD) between random points to assess the geometry properties of learned surfaces. The lower these two metrics, the smoother recovered object surfaces. Owing to the absence of such two metrics on ground-truth surfaces for reference, we consider the smoother surfaces better conform to ground-truth cases. The reported values on these two metrics are averaged over 100 randomly synthesized 3D meshes. Quantitative comparisons in Table 3 demonstrate our method GOF can preserve better geometry properties. ",
+        "bbox": [
+            173,
+            704,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/c20bafb595ef5d7fa5bc4c0af2f9acc0c1208d6bb2c6dfcbecdce20dd989e116.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            87,
+            816,
+            345
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/fe2f6263b603daba3a83f200e962cbc2b4ca2663d8e455e97bf4bdbe003bba8b.jpg",
+        "image_caption": [
+            "Figure 5: Rendering with only surface points. Images (right) rendered only with surface points are indistinguishable from those (left) obtained with cumulative rendering. ",
+            "Figure 6: Qualitative ablation on proposed priors (upper row w/o $\\mathcal { L } _ { \\mathrm { o p a c i t y } }$ , bottom row w/o $\\mathcal { L } _ { \\mathrm { { n o r m a l } } }$ ). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            383,
+            813,
+            522
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Rendering only with surface points. As mentioned in Sec. 3.2, GOF is able to render an image using only the surface points. To verify this, we showcase in Fig. 5 images rendered by GOF using multiple points and only the surface point. As can be observed, images synthesized with these two strategies are nearly indistinguishable from each other. Thus, GOF possesses the potential to significantly reduce the number of generator queries when synthesizing an image. To compare the efficiency straightforwardly, we estimate the rendering speed of $2 5 6 \\times 2 5 6$ images for both pi-GAN and GOF on a single Intel Xeon(R) CPU. On average, pi-GAN costs about 78s per image, while GOF takes about 56s, saving approximately $2 8 \\%$ of the time. Owing to the reduction in the burden of queries, GOF enables a light rendering scheme that is promising for applications on mobile devices. ",
+        "bbox": [
+            174,
+            559,
+            825,
+            684
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ablation studies. We here analyze the effects of the proposed regularizations ${ \\mathcal { L } } _ { \\mathrm { n o r m a l } }$ and $\\mathcal { L } _ { \\mathrm { o p a c i t y } }$ Table 1 includes the quantitative ablation study on these priors. We also include qualitative samples in Fig. 6, which contains images synthesized by GOF without one regularization item. As shown in the BFM cases 6(a), removing opacity prior leads to the smoke-like artifacts around the cheek part and the absence of normal regularization might degrade the quality of learned normal maps. While testing on the real-world dataset 6(b), undesirable specular highlights emerge on the face and the hollows appear on the corresponding shapes if without the normal regularization. Moreover, we observe that removing opacity prior on CelebA dataset will make the face surfaces too flat and unnatural. It is worth noting that although the performance of GOF is deteriorated due to the absence of these priors, images and surfaces produced by GOF are still of reasonable quality when compared to that from previous approaches, indicating the transition from radiance fields to occupancy fields is the main cause that leads to the success of GOF. Moreover, we showcase the degenerated results on BFM dataset if our model is trained without the shrinking process. As illustrated in Fig. 7, despite the realistic generated images, there emerges random noise on the corresponding normal maps and some nasty dents appear on the face shapes, which demonstrates that the combination of our proposed occupancy representation and the shrinking sampling procedure ensures the surface compactness. ",
+        "bbox": [
+            174,
+            690,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/2e63847e62eb4fcb42c3cea2912d095c6950567cf2c7548ca11ad33ff7ab0e8b.jpg",
+        "image_caption": [
+            "Figure 7: GOF results without the shrinking process. Noise emerges on normals and dents appear on shapes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            89,
+            395,
+            215
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/a907662b559911063e7819033757f9a4f74bf1aa539a5f3860dc58fe58fbe1cb.jpg",
+        "image_caption": [
+            "Figure 8: GAN inversion results on real images. GOF can reconstruct the target images and simultaneously learn the corresponding normal maps as well as 3D shapes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            405,
+            92,
+            818,
+            213
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/c31620b9ba6ed83b55c6864d7ece026799eb5f6d372621310c845f2aada1e1c8.jpg",
+        "image_caption": [
+            "Figure 9: Relighting results. Our method GOF generates desirable images under various light conditions while baseline results are far from satisfactory. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            280,
+            820,
+            417
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Inverse rendering. Through GAN inversion, our method is also capable of inverse rendering as shown in Fig. 8. Given a real image, GOF can reconstruct the target image successfully and realize free view synthesis by controlling the viewpoints. Besides, the recovered normal maps as well as 3D shapes pave the way for downstream tasks such as relighting and editing. ",
+        "bbox": [
+            174,
+            469,
+            825,
+            525
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Relighting. In Fig. 9 we provide the relighting results based on the learned normal maps by explicitly controlling the lighting directions. As our method and baselines can’t predict the corresponding albedo, the face-forwarding image is considered as the pseudo albedo. Thanks to better learned normal maps, our method GOF presents promising images under different light conditions. In contrast to ours, baseline methods like pi-GAN [6] tend to generate messy normal maps with obvious checkerboard-like artifacts, leading to noisy and dissatisfied relighting results. ",
+        "bbox": [
+            174,
+            531,
+            825,
+            614
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Limitations. While training on real-world datasets, our method GOF might present similar dents in the hair regions as in existing approaches [6]. Besides, the adopted FiLMed-SIREN backbone in the generator will lead to stripe artifacts in the generated images especially when they are rendered only with surface points. Meanwhile, surface rendering mode will make furry cat images over-smooth and less realistic. Moreover, our method is more suitable for solid objects with only one surface. ",
+        "bbox": [
+            174,
+            621,
+            825,
+            690
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            712,
+            299,
+            729
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this work, we propose generative occupancy fields (GOF), a novel generative radiance fields for 3D-aware image synthesis. The crux of GOF is a dedicated transition from the cumulative rendering in radiance fields to rendering with only the surface points. Such a transition is inspired by the resemblance between the alpha values in radiance fields and the occupancy values in occupancy networks, so that we can reinterpret one as the other. In practice, such a transition is achieved during training by gradually shrinking the sampling region in the rendering process of GOF from the entire volume to a minimal neighboring region around the surface, where the surface is located via rootfinding on predicted alpha values. Thanks to the transition, surfaces learned by GOF continuously converge during the training, ensuring their compactness at the end. On three diverse datasets, GOF is shown to demonstrate great superiority in synthesizing 3D consistent images and in the meantime capturing compact surfaces, significantly broadening the application of generative radiance fields in downstream tasks. ",
+        "bbox": [
+            174,
+            746,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowlegements ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            89,
+            326,
+            106
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We would like to thank Eric R. Chan for sharing the codebase of pi-GAN. This work is supported by the Collaborative Research Grant from SenseTime (CUHK Agreement No. TS1712093), the General Research Fund (GRF) of Hong Kong (No. 14205719), the RIE2020 Industry Alignment Fund – Industry Collaboration Projects (IAF-ICP) Funding Initiative, as well as cash and in-kind contribution from the industry partner(s). ",
+        "bbox": [
+            174,
+            119,
+            825,
+            189
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            209,
+            266,
+            224
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] I. J. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair, A. C. Courville, and Y. Bengio, “Generative adversarial nets,” in NIPS, 2014.   \n[2] A. Brock, J. Donahue, and K. Simonyan, “Large scale gan training for high fidelity natural image synthesis,” in International Conference on Learning Representations, 2018.   \n[3] T. Karras, S. Laine, and T. Aila, “A style-based generator architecture for generative adversarial networks,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 4401–4410, 2019.   \n[4] T. Karras, S. Laine, M. Aittala, J. Hellsten, J. Lehtinen, and T. Aila, “Analyzing and improving the image quality of stylegan,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 8110–8119, 2020.   \n[5] B. Mildenhall, P. P. Srinivasan, M. Tancik, J. T. Barron, R. Ramamoorthi, and R. Ng, “Nerf: Representing scenes as neural radiance fields for view synthesis,” in ECCV, pp. 405–421, Springer, 2020.   \n[6] E. R. Chan, M. Monteiro, P. Kellnhofer, J. Wu, and G. Wetzstein, “pi-gan: Periodic implicit generative adversarial networks for 3d-aware image synthesis,” in CVPR, 2021.   \n[7] K. Schwarz, Y. Liao, M. Niemeyer, and A. Geiger, “Graf: Generative radiance fields for 3d-aware image synthesis,” in NeurIPS, vol. 33, 2020.   \n[8] L. Mescheder, M. Oechsle, M. Niemeyer, S. Nowozin, and A. Geiger, “Occupancy networks: Learning 3d reconstruction in function space,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 4460–4470, 2019.   \n[9] L. Yariv, Y. Kasten, D. Moran, M. Galun, M. Atzmon, B. Ronen, and Y. Lipman, “Multiview neural surface reconstruction by disentangling geometry and appearance,” Advances in Neural Information Processing Systems, vol. 33, 2020.   \n[10] M. Oechsle, S. Peng, and A. Geiger, “Unisurf: Unifying neural implicit surfaces and radiance fields for multi-view reconstruction,” arXiv preprint arXiv:2104.10078, 2021.   \n[11] M. Niemeyer, L. Mescheder, M. Oechsle, and A. Geiger, “Differentiable volumetric rendering: Learning implicit 3d representations without 3d supervision,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 3504–3515, 2020.   \n[12] Y. Jiang, D. Ji, Z. Han, and M. Zwicker, “Sdfdiff: Differentiable rendering of signed distance fields for 3d shape optimization,” in The IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2020.   \n[13] S. Liu, Y. Zhang, S. Peng, B. Shi, M. Pollefeys, and Z. Cui, “Dist: Rendering deep implicit signed distance function with differentiable sphere tracing,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 2019–2028, 2020.   \n[14] J. J. Park, P. Florence, J. Straub, R. Newcombe, and S. Lovegrove, “Deepsdf: Learning continuous signed distance functions for shape representation,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 165–174, 2019.   \n[15] Z. Chen and H. Zhang, “Learning implicit fields for generative shape modeling,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 5939–5948, 2019.   \n[16] K. Genova, F. Cole, D. Vlasic, A. Sarna, W. T. Freeman, and T. Funkhouser, “Learning shape templates with structured implicit functions,” in Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 7154–7164, 2019.   \n[17] M. Michalkiewicz, J. K. Pontes, D. Jack, M. Baktashmotlagh, and A. Eriksson, “Implicit surface representations as layers in neural networks,” in Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 4743–4752, 2019.   \n[18] S. Saito, Z. Huang, R. Natsume, S. Morishima, A. Kanazawa, and H. Li, “Pifu: Pixel-aligned implicit function for high-resolution clothed human digitization,” in Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 2304–2314, 2019.   \n[19] S. Saito, T. Simon, J. Saragih, and H. Joo, “Pifuhd: Multi-level pixel-aligned implicit function for high-resolution 3d human digitization,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 84–93, 2020.   \n[20] V. Sitzmann, E. R. Chan, R. Tucker, N. Snavely, and G. Wetzstein, “Metasdf: Meta-learning signed distance functions,” arXiv preprint arXiv:2006.09662, 2020.   \n[21] V. Sitzmann, M. Zollhöfer, and G. Wetzstein, “Scene representation networks: Continuous 3d-structure-aware neural scene representations,” in Advances in Neural Information Processing Systems, 2019.   \n[22] L. Liu, J. Gu, K. Z. Lin, T.-S. Chua, and C. Theobalt, “Neural sparse voxel fields,” arXiv preprint arXiv:2007.11571, 2020.   \n[23] A. Yu, R. Li, M. Tancik, H. Li, R. Ng, and A. Kanazawa, “Plenoctrees for real-time rendering of neural radiance fields,” arXiv preprint arXiv:2103.14024, 2021.   \n[24] T. Neff, P. Stadlbauer, M. Parger, A. Kurz, J. H. Mueller, C. R. A. Chaitanya, A. Kaplanyan, and M. Steinberger, “Donerf: Towards real-time rendering of compact neural radiance fields using depth oracle networks,” arXiv preprint arXiv:2103.03231, 2021.   \n[25] P. Hedman, P. P. Srinivasan, B. Mildenhall, J. T. Barron, and P. Debevec, “Baking neural radiance fields for real-time view synthesis,” arXiv preprint arXiv:2103.14645, 2021.   \n[26] M. Boss, R. Braun, V. Jampani, J. T. Barron, C. Liu, and H. Lensch, “Nerd: Neural reflectance decomposition from image collections,” arXiv preprint arXiv:2012.03918, 2020.   \n[27] P. P. Srinivasan, B. Deng, X. Zhang, M. Tancik, B. Mildenhall, and J. T. Barron, “Nerv: Neural reflectance and visibility fields for relighting and view synthesis,” arXiv preprint arXiv:2012.03927, 2020.   \n[28] M. Atzmon, N. Haim, L. Yariv, O. Israelov, H. Maron, and Y. Lipman, “Controlling neural level sets,” arXiv preprint arXiv:1905.11911, 2019.   \n[29] P. Kellnhofer, L. C. Jebe, A. Jones, R. Spicer, K. Pulli, and G. Wetzstein, “Neural lumigraph rendering,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 4287–4297, 2021.   \n[30] J. Wu, C. Zhang, T. Xue, B. Freeman, and J. Tenenbaum, “Learning a probabilistic latent space of object shapes via 3d generative-adversarial modeling,” in NIPS, 2016.   \n[31] X. Chen, D. Cohen-Or, B. Chen, and N. J. Mitra, “Towards a neural graphics pipeline for controllable image generation,” Computer Graphics Forum, vol. 40, no. 2, 2021.   \n[32] J.-Y. Zhu, Z. Zhang, C. Zhang, J. Wu, A. Torralba, J. Tenenbaum, and B. Freeman, “Visual object networks: Image generation with disentangled 3d representations,” in NeurIPS, 2018.   \n[33] Y. Liao, K. Schwarz, L. Mescheder, and A. Geiger, “Towards unsupervised learning of generative models for 3d controllable image synthesis,” in CVPR, pp. 5871–5880, 2020.   \n[34] T. Nguyen-Phuoc, C. Richardt, L. Mai, Y.-L. Yang, and N. Mitra, “Blockgan: Learning 3d object-aware scene representations from unlabelled images,” in Advances in Neural Information Processing Systems 33, Nov 2020.   \n[35] T. Nguyen-Phuoc, C. Li, L. Theis, C. Richardt, and Y.-L. Yang, “Hologan: Unsupervised learning of 3d representations from natural images,” in ICCV, pp. 7588–7597, 2019.   \n[36] M. Niemeyer and A. Geiger, “Giraffe: Representing scenes as compositional generative neural feature fields,” in CVPR, 2021.   \n[37] S. Wu, C. Rupprecht, and A. Vedaldi, “Unsupervised learning of probably symmetric deformable 3d objects from images in the wild,” in CVPR, 2020.   \n[38] X. Pan, B. Dai, Z. Liu, C. C. Loy, and P. Luo, “Do 2d gans know 3d shape? unsupervised 3d shape reconstruction from 2d image gans,” in ICLR, 2021.   \n[39] M. Sahasrabudhe, Z. Shu, E. Bartrum, R. Alp Guler, D. Samaras, and I. Kokkinos, “Lifting autoencoders: Unsupervised learning of a fully-disentangled 3d morphable model using deep non-rigid structure from motion,” in ICCV Workshops, pp. 0–0, 2019.   \n[40] X. Li, S. Liu, K. Kim, S. De Mello, V. Jampani, M.-H. Yang, and J. Kautz, “Self-supervised single-view 3d reconstruction via semantic consistency,” ECCV, 2020.   \n[41] P. Wang, L. Liu, Y. Liu, C. Theobalt, T. Komura, and W. Wang, “Neus: Learning neural implicit surfaces by volume rendering for multi-view reconstruction,” arXiv preprint arXiv:2106.10689, 2021.   \n[42] L. Yariv, J. Gu, Y. Kasten, and Y. Lipman, “Volume rendering of neural implicit surfaces,” arXiv preprint arXiv:2106.12052, 2021.   \n[43] J. T. Kajiya and B. P. Von Herzen, “Ray tracing volume densities,” ACM SIGGRAPH computer graphics, vol. 18, no. 3, pp. 165–174, 1984.   \n[44] Z. Liu, P. Luo, X. Wang, and X. Tang, “Deep learning face attributes in the wild,” in ICCV, pp. 3730–3738, 2015.   \n[45] P. Paysan, R. Knothe, B. Amberg, S. Romdhani, and T. Vetter, “A 3d face model for pose and illumination invariant face recognition,” in 2009 Sixth IEEE International Conference on Advanced Video and Signal Based Surveillance, pp. 296–301, Ieee, 2009.   \n[46] W. Zhang, J. Sun, and X. Tang, “Cat head detection-how to effectively exploit shape and texture features,” in ECCV, pp. 802–816, Springer, 2008. ",
+        "bbox": [
+            171,
+            229,
+            826,
+            915
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            60,
+            828,
+            914
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            168,
+            85,
+            828,
+            583
+        ],
+        "page_idx": 12
+    }
+]