Neural Discrete Representation Learning
Learning useful representations without supervision remains a key challenge in machine learning. In this paper, we propose a simple yet powerful generative model that learns such discrete representations. Our model, the Vector QuantisedVariational AutoEncoder (VQ-VAE), differs from VAEs in two key ways: the encoder network outputs discrete, rather than continuous, codes; and the prior is learnt rather than static. In order to learn a discrete latent representation, we incorporate ideas from vector quantisation (VQ). Using the VQ method allows the model to circumvent issues of "posterior collapse" --where the latents are ignored when they are paired with a powerful autoregressive decoder --typically observed in the VAE framework. Pairing these representations with an autoregressive prior, the model can generate high quality images, videos, and speech as well as doing high quality speaker conversion and unsupervised learning of phonemes, providing further evidence of the utility of the learnt representations.

Summary-
This paper describes a VAE model in which the latent space consists of
discrete-valued (multinomial) random variables. VAEs with multinomial latent
variables have been proposed before. This model differs in the way it computes
which state to pick and how it sends gradients back. Previous work has used
sampled softmaxes, and other softmax-based ideas (for example, trying to start
with something more continuous and anneal to hard). In this work, a VQ approach
is used, where a hard decision is made to pick the closest embedding space
vector. The gradients are sent into both into the embedding space and the
encoder.
Strengths
- The model is tested on many different datasets including images, audio, and video datasets.
- The model gets good results which are comparable to those obtained with continuous latent variables.
- The paper is well-written and easy to follow.
Weaknesses-
- Experimental comparisons with other discrete latent variable VAE approaches
are not reported. It is mentioned that the proposed model is the first to
achieve comparable performance with continuous latent variable models, but it
would be useful to provide a quantitative assessment as well.
- The motivation for having discrete latent variables is not entirely
convincing. Even if the input space is discrete, it is not obvious why the
latent space should be. For example, the paper argues that "Language is
inherently discrete, similarly speech is typically represented as a sequence of
symbols" and that this makes discrete representations a natural fit for such
domains. However, the latent semantic representation of words or speech could
still be continuous, which would make it possible to capture subtle inflections
in meaning or tone which might otherwise be lost in a discretized or quantized
representation. The applications to compression are definitely more convincing.
Overall-
The use of VQ to work with discrete latent variables in VAEs is a novel
contribution. The model is shown to work well on a multiple domains and
datasets. While the qualitative results are convincing, the paper can be made
more complete by including some more comparisons, especially with other ways of
producing discrete latent representations.


PixelGAN Autoencoders
In this paper, we describe the "PixelGAN autoencoder", a generative autoencoder in which the generative path is a convolutional autoregressive neural network on pixels (PixelCNN) that is conditioned on a latent code, and the recognition path uses a generative adversarial network (GAN) to impose a prior distribution on the latent code. We show that different priors result in different decompositions of information between the latent code and the autoregressive decoder. For example, by imposing a Gaussian distribution as the prior, we can achieve a global vs. local decomposition, or by imposing a categorical distribution as the prior, we can disentangle the style and content information of images in an unsupervised fashion. We further show how the PixelGAN autoencoder with a categorical prior can be directly used in semi-supervised settings and achieve competitive semi-supervised classification results on the MNIST, SVHN and NORB datasets.

Update after rebuttal: I believe the paper can be accepted as a poster. I advise the authors to polish the writing to better highlight their contributions, motivation and design choices. This could make the work attractive and rememberable, not "yet another hybrid generative model".
-----
The paper proposes PixelGAN autocencoder - a generative model which is a hybrid of an adversarial autoencoder and a PixelCNN autoencoder. The authors provide a theoretical justification of the approach based on a decomposition of variational evidence lower bound (ELBO). The authors provide qualitative results with different priors on the hidden distribution, and quantitative results on semi-supervised learning on MNIST, SVHN and NORB.
The paper is closely related to Adversarial autoencoders (Makhzani et al. ICLR 2016 Workshop), which, as far as I know, have only been published on arxiv and as a Workshop contribution to ICLR. Yet, the work is well known and widely cited. The novelty of the present submission significantly depends on Adversarial autoencoders being considered existing approach or not. This is a complicated situation, which, I assume, ACs and PCs are better qualified to judge about.
Now to some more detailed comments.
Pros:
1) Good results on semi-supervised learning on MNIST, SVHN and NORB, and unsupervised clustering on MNIST. It is difficult to say if the results are state-of-the-art since many numbers for the baselines are missing, but at least they are close to the state of the art.
2) A clear discussion of an ELBO decomposition and related architectural choices.
Cons:
1) If Adversarial autoencoders are considered existing work, then novelty is somewhat limited - it’s yet another paper which combines two existing generative models. What makes exactly this combination especially interesting?
2) Lack of results on actual image generation. I understand that image generation is difficult to evaluate, but still some likelihood bounds (are these even computable?), Inception scores and images would be nice to see, at least in the Appendix.
3) It is somewhat confusing that two versions of the approach - with location-dependent and location-independent biases - are used in experiments interchangeably, but are not directly compared to each other. I appreciate the authors mentioning this in lines 153-157, but a more in-depth analysis would be useful.
4) A more detailed discussion of relation to existing approaches, such as VLAE and PixelVAE (both published at ICLR 2017), would be helpful. Lines  158-163 are helpful, but do not quite clear highlight the differences, and strengths and weaknesses of different approaches.
5) Some formulations are not quite clear, such as “limited stochasticity” vs “powerful decoder” in lines 88 and 96. Also the statement in line 111 about “approximately optimizing the KL divergence” and the corresponding footnote looks a bit too abstract - so do the authors optimize it or not?
6) In the bibliography the authors tend to ignore the ICLR conference and list many officially published papers as arxiv.
7) Putting a whole section on cross-domain relations to the appendix is not good practice at all. I realize it’s difficult to fit all content to 8 pages, but it’s the job of the authors to organize the paper in such a way that all important contributions fit into the main paper.
Overall, I am in the borderline mode. The results are quite good, but the novelty seems limited.


The Importance of Communities for Learning to Influence
We consider the canonical problem of influence maximization in social networks. Since the seminal work of Kempe, Kleinberg, and Tardos [KKT03]  there have been two, largely disjoint efforts on this problem. The first studies the problem associated with learning the generative model that produces cascades, and the second focuses on the algorithmic challenge of identifying a set of influencers, assuming the generative model is known. Recent results on learning and optimization imply that in general, if the generative model is not known but rather learned from training data, no algorithm for influence maximization can yield a constant factor approximation guarantee using polynomially-many samples, drawn from any distribution. In this paper we describe a simple algorithm for maximizing influence from training data. The main idea behind the algorithm is to leverage the strong community structure of social networks and identify a set of individuals who are influentials but whose communities have little overlap. Although in general, the approximation guarantee of such an algorithm is unbounded, we show that this algorithm performs well experimentally. To analyze its performance, we prove this algorithm obtains a constant factor approximation guarantee on graphs generated through the stochastic block model, traditionally used to model networks with community structure.

This work marries influence maximization (IM) with recent work on submodular optimization from samples. The work salvages some positive results from the wreckage of previous impossibility results on IM from samples, by showing that under an SBM model of community structure in graphs, positive results for IM under sampling are possible with a new algorithm (COPS) that is a new variation on other greedy algorithms for IM. It’s surprising that the removal step in the COPS algorithm is sufficient from producing the improvement seen between Margl and COPS in Figure 2 (where Margl sometimes does worse than random). Overall this is a strong contribution to the IM literature.
Pros:
- Brings IM closer to practical contexts by studying IM under learned influence functions
- Gives rigorous analysis of this problem for SBMs
- Despite simplicity of SBMs, solid evaluation shows good performance on real data
Cons:
- The paper is very well written, but sometimes feels like it oversimplifies the literature in the service of somewhat overstating the importance of the paper. But it’s good work.
- The paper could use a conclusion.
1) The use of “training data” in the title makes it a bit unclear what the paper is about. I actually thought the paper was going to be about something very different, some curious application of IM to understand how training data influences machine learning models in graph datasets. Having read the abstract it made more sense, but the word “training” is only used once beyond the abstract, in a subsection title. It seemed as though the focus on SBMs and community structure deserve mentioning in the title?
2) The SBM is a very simplistic model of “communities,” and it’s important to stay humble about what’s really going on in the theoretical results: the positive results for SBMs in this work hinge on the fact that within communities, SBM graphs are just ER graphs, and the simple structure of these ER graphs is what is powering the results.
3) With (2) registered as a minor grievance, the empirical results are really quite striking, given that the theoretical analysis assumes ER structure within the communities. It’s also notable that the COPS algorithm really does quite well even graphs from on the BA model, which is far from an SBM. In some sense, the issue in (2) sets up an expectation (at least for me) that COPS won’t "actually work". This is quite intriguing, and suggests that the parts of the analysis relying on the ER structure are not using the strongest properties of it (i.e., something close to the main result holds for models much more realistic than ER). This is a strong property of the work, inviting future exploration.
Minor points:
1) The dichotomous decomposition of the IM literature is a little simplistic, and some additional research directions deserve mention. There has been several recent works that consider IM beyond submwdular cases, notably the “robust IM” work by [HK16] (which this submission cites as focusing on submwdular IM, not wrong) and also [Angell-Schoenebeck, arxiv 2016].
2) Two broken cites in Section 3.1. Another on line 292. And I think I see at least one more. Check cites.
3) The name COPS changes to Greedy-Prune in Section 5 (this reviewer assumes they refer to the same thing).
4) I really prefer for papers to have conclusions, even if the short NIPS format makes that a tight fit.


Smooth Primal-Dual Coordinate Descent Algorithms for Nonsmooth Convex Optimization
We propose a new randomized coordinate descent method for a convex optimization template with broad applications. Our analysis relies on a novel combination of four ideas applied to the primal-dual gap function: smoothing, acceleration, homotopy, and coordinate descent with non-uniform sampling. As a result, our method features the first convergence rate guarantees among the coordinate descent methods, that are the best-known under a variety of common structure assumptions on the template. We provide numerical evidence to support the theoretical results with a comparison to state-of-the-art algorithms.

The authors propose a new smooth primal-dual randomized coordinate descent method for the three composite problem F(x) = f(x) + g(x) + h(Ax), where f is smooth, g is non-smooth, separable and has a block-wise proximal operator, and h is a general nonsmooth function. The method is basically a generalization of the accelerated, parallel, and proximal coordinate descent method of Fercoq and Richtarik, and the coordinate descent method with arbitrary sampling of Qu and Richtarik to the three composite case. The difficulty of this extension lies in the non-smoothness of the function h composed with a linear operator A. The authors provide an efficient implementation by breaking up full vector updates. They show that the algorithm achieves the best known O(n/k) convergence rate. Restart schemes are also used to improve practical performance. Special cases of the three composite problem are considered and analyzed.
The contributions are clearly stated and overall, this is a nice paper. It is applicable to many different objective functions and employs all the "tricks" to make this a fast and efficient method.
Comments:
- The smoothing and non-uniform sampling techniques of Algorithm 1 are clearly described in Section 2, but the homotopy and acceleration techniques are not described anywhere, they are just directly used in Alg 1. This makes Alg. 1 a little cryptic if you are unfamiliar with the structure of these methods -- I think Alg. 1 needs to be better explained either in words or indicating what method/approach each step corresponds to.
- Following from the previous comment, ll 9 of Algorithm 1 - where does this formula for \tau come from?, ll 153 - where does the adapted \tau formula come from for the strongly convex case? This is not clear.
- What are the values of \hat{x}, \tilde{x} and \bar{x} initialized to in Alg 1?
- What is the "given" value of \dot{y} (re: line 73 and equation (6))?
- Unknown reference in line 165.
============
POST REBUTTAL
============
I have read the author rebuttal and the other reviews. I thank the authors for addressing my comments/questions, as well as the comments/questions of the other reviewers. My recommendation stands, I think this paper should be accepted.


Is the Bellman residual a bad proxy?
This paper aims at theoretically and empirically comparing two standard optimization criteria for Reinforcement Learning: i) maximization of the mean value and ii) minimization of the Bellman residual. For that purpose, we place ourselves in the framework of policy search algorithms, that are usually designed to maximize the mean value, and derive a method that minimizes the residual T * v π − v π 1,ν over policies. A theoretical analysis shows how good this proxy is to policy optimization, and notably that it is better than its value-based counterpart. We also propose experiments on randomly generated generic Markov decision processes, specifically designed for studying the influence of the involved concentrability coefficient. They show that the Bellman residual is generally a bad proxy to policy optimization and that directly maximizing the mean value is much better, despite the current lack of deep theoretical analysis. This might seem obvious, as directly addressing the problem of interest is usually better, but given the prevalence of (projected) Bellman residual minimization in value-based reinforcement learning, we believe that this question is worth to be considered.

The paper investigates a fundamental question in RL, namely whether we should directly maximize the mean value, which is the primary objective, or if it is suitable to minimize the Bellman residual, as is done by several algorithms.  The paper provides new theoretical analysis, in the form of a bound on residual policy search.  This is complemented by a series of empirical results with random (Garnet-type) MDPs.   The paper has a simple take-home message, which is that minimizing the Bellman residual is more susceptible to mismatch between the sample distribution and the optimal distribution, compared to policy search methods that directly optimize the value.
The papes is well written; it outlines a specific question, and provides both theoretical and empirical support for answering this question.  The new theoretical analysis extends previous known results.  It is a modest extension, but potentially useful, and easy to grasp.  The empirical results are informative, and constructed to shed light on the core question.  I would be interested in seeing analogous results for standard RL benchmarks, to verify that the results carry over to "real" MDPs, not just random, but that is a minor point.
One weakness of the work might be its scope: it is focused on a simple setting of policy search, without tackling implication of the work for more complex settings more commonly used, such as TRPO, DDPG.


Inference in Graphical Models via Semidefinite Programming Hierarchies
Maximum A posteriori Probability (MAP) inference in graphical models amounts to solving a graph-structured combinatorial optimization problem. Popular inference algorithms such as belief propagation (BP) and generalized belief propagation (GBP) are intimately related to linear programming (LP) relaxation within the Sherali-Adams hierarchy. Despite the popularity of these algorithms, it is well understood that the Sum-of-Squares (SOS) hierarchy based on semidefinite programming (SDP) can provide superior guarantees. Unfortunately, SOS relaxations for a graph with n vertices require solving an SDP with n ⇥(d) variables where d is the degree in the hierarchy. In practice, for d 4, this approach does not scale beyond a few tens of variables. In this paper, we propose binary SDP relaxations for MAP inference using the SOS hierarchy with two innovations focused on computational efficiency. Firstly, in analogy to BP and its variants, we only introduce decision variables corresponding to contiguous regions in the graphical model. Secondly, we solve the resulting SDP using a non-convex Burer-Monteiro style method, and develop a sequential rounding procedure. We demonstrate that the resulting algorithm can solve problems with tens of thousands of variables within minutes, and outperforms BP and GBP on practical problems such as image denoising and Ising spin glasses. Finally, for specific graph types, we establish a sufficient condition for the tightness of the proposed partial SOS relaxation.

The authors show how SDP methods based on the Sum-of-Squares (SOS) hierarchy may be used for MAP inference in discrete graphical models, focusing on binary pairwise models. Specifically, an approximate method for binary pairwise models is introduced to solve what is called PSOS(4), then the solution is rounded to an integer solution using a recursive scheme called CLAP (for Confidence Lift And Project). Preliminary empirical results are presented which appear encouraging.
This is an interesting direction but I was confused by several aspects. Please could the authors clarify/note the following:
1. l.60-67 Optimizing an LP over a relaxation in the Sherali-Adams hierarchy, and relation to Theorem 1.
For the first order relaxation, i.e. the standard pairwise local polytope, only edges in the original model need be considered. This is because, in this case, it is straightforward to observe that consistent marginals for the other edges (which do not exist in the original model) exist while remaining in the pairwise polytope for the complete graph. By asusmption their values do not affect the optimum.
For the next higher order relaxation, i.e. the triplet-consistent polytope TRI, in fact again it may be shown *for binary pairwise models whose graph is chordal* that one need only consider triangles in the original model, since there always exist consistent marginals for all other edges. This is not obvious and was shown recently by Rowland, Pacchiano and Weller "Conditions beyond treewidth..." AISTATS 2017, Sec 3.3.
This theme is clearly relevant to your approach, as described in l.81-89. Further, properties of TRI (equivalent for binary pairwise models to the cycle polytope, see Sontag PhD thesis 2010) may be highly relevant for this paper since I believe that the proof for Theorem 1 relies on showing essentially that the SOS(4) relaxation lies within TRI - please could you comment? If that is true, is it true for any binary pairwise model or only subject to certain restrictions?
2. l.72 Here you helpfully suggest that SDP relaxations do not account well for correlations between neighboring vertices. It would be very valuable if you could please elaborate on this, and other possible negatives of your approach, to provide a balanced picture. Given this observation, why then does your method appear to work well in the empirical examples you show later?
3. I appreciate space constraints are very tight but if possible to elaborate (even in the Appendix) on the approach, it would be very helpful. In particular: what exactly is happening when r is varied for a given model; how should we think about the directed i->j constraints in l.124-5?
4. Alg 1. When will this algorithm perform well/badly? Can any guarantees be provided, e.g. will it give an upper bound on the solution?
5. CLAP Alg 2. Quick check: is this guaranteed to terminate? [maybe for binary pairwise models, is < \sigma_0, \sigma_s > always \geq 1/2 or some other bound?]
Could you briefly discuss its strengths and weaknesses. Are other methods such as Barak, Kelner, Steuer 2014 "Rounding sum-of-squares relaxations" relevant?
6. Sec 4 Experiments.
When you run BP-SP, you obtain marginals. How do you then compute your approximate MAP solution? Do you use the same CLAP rounding approach or something else? This may be important since in your experiments, BP-SP performs very well.
Since you use triangles as regions for PSOS(4), could you try the same for GBP to make the comparison more similar? Particularly since it appears somewhat odd that the current GBP with 4-sets is not doing better than BP-SP.
Times should be reported for all methods to allow more meaningful comparisons [I recognize this can be tricky with non-optimized code but the pattern as larger models are examined would still be helpful].
If possible, it would be instructive to add experiments for larger planar models with no singleton potentials, where it is feasible to compute the exact MAP score.
Minor points:
In a few places, claims are perhaps stronger than justified - e.g. in the Abstract, "significantly outperforms BP and GBP" ; l. 101 perhaps remove "extensive"; l. 243 - surely the exact max was obtained only for the small experiments; you don't know for the larger models?
A few capitalizations are missing in the References, e.g. Ising, Burer-Monteiro, SDP
=======================
I have read the rebuttal and thank the authors for addressing some of my concerns.


A Unified Approach to Interpreting Model Predictions
Understanding why a model makes a certain prediction can be as crucial as the prediction's accuracy in many applications. However, the highest accuracy for large modern datasets is often achieved by complex models that even experts struggle to interpret, such as ensemble or deep learning models, creating a tension between accuracy and interpretability. In response, various methods have recently been proposed to help users interpret the predictions of complex models, but it is often unclear how these methods are related and when one method is preferable over another. To address this problem, we present a unified framework for interpreting predictions, SHAP (SHapley Additive exPlanations). SHAP assigns each feature an importance value for a particular prediction. Its novel components include: (1) the identification of a new class of additive feature importance measures, and (2) theoretical results showing there is a unique solution in this class with a set of desirable properties. The new class unifies six existing methods, notable because several recent methods in the class lack the proposed desirable properties. Based on insights from this unification, we present new methods that show improved computational performance and/or better consistency with human intuition than previous approaches.

The authors show that several methods in the literature used for explaining individual model predictions fall into the category of "additive feature attribution" methods. They proposes a new kind of additive feature attribution method based on the concept of Shapely values and call the resulting explanations the SHAP values. The authors also suggest a new kernel called the shapely kernel which can be used to compute SHAP values via linear regression (a method they call kernel SHAP). They discuss how other methods, such as DeepLIFT, can be improved by better approximating the Shapely values.
Summary of review:
Positives:
(1) Novel and sound theoretical framework for approaching the question of model explanations, which has been very lacking in the field (most other methods were developed ad-hoc).
(2) Early versions of this paper have already been cited to justify improvements in other methods (specifically New DeepLIFT).
(3) Kernel SHAP is a significantly superior way of approximating Shapely values compared to classical Shapely sampling - much lower variance vs. number of model evaluations (Figure 3).
Negatives:
(1) Algorithm for Max SHAP is incorrect
(2) Proof for Kernel SHAP included in supplement is incomplete and hastily written
(3) Paper has significant typos: main text says runtime of Max SHAP is O(M^3) but supplement says O(M^2), equation for L under Theorem 2 has a missing close parenthesis for f()
(4) Argument that SHAP values are a superior form of model explanation is contentious. Case studies in Figure 4 have been chosen to favor SHAP. Paper doesn't have a discussion of the runtime for kernel SHAP or the recommended number of function evaluations needed for good performance. LIME was not included in the Figure 5 comparison.
Detailed comments:
The fact that Shapely values can be adapted to the task of model explanations is an excellent insight, and early versions of this paper have already been used by other authors to justify improvements to their methods (specifically New DeepLIFT). Kernel SHAP seems like a very significant contribution because, based on Figure 3, it has far lower variance compared to Shapely sampling when estimating the true Shapely values. It is also appealing because, unlike the popular method LIME, the choice of kernel here is motivated by a sound theoretical foundation.
However, there are a few problems with the paper. The algorithm for Max SHAP assumes that when i1 is greater than i2 and i2 is the largest input seen so far, then including i1 contributes (i1 - max(reference_of_i1, i2)) to the output. However, this is only true if none of the inputs which haven't been included yet have a reference value that exceeds max(reference_of_i1, i2). To give a concrete example, imagine there are two inputs, a and b, where a=10 and b=6, and the reference values are ref_a = 9 and ref_b = 0. The reference value of max(a,b) is 9, and the difference-from-reference is 10. The correct SHAP values are 1 for a and 0 for b, because b is so far below the reference of a that it never influences the output. However, the line phi[ind] += max(ref,0)/M will assign a SHAP value of 3 to b (ref = xsorted[i] - r[ind], which is 6-0 for b, and M=2). In the tests, it appears that the authors only checked cases where all inputs had the same reference. While this is often true of maxpooling neurons, it need not be true of maxout neurons. Also, the algorithm seems difficult to implement on a GPU in a way that would not significantly slow down backpropagation, particularly in the case of maxpooling layers. That said, this algorithm is not central to the thesis of the paper and was clearly written in a rush (the main text says the runtime is O(M^3) but the supplement says the runtime is O(M^2)).
Additionally, when I looked up the "Shapely kernel proof" in the supplement, the code provided for the computational proof was incomplete and the explanation was terse and contained grammatical errors. After several re-reads, my understanding of the proof is that:
(1) f_x(S) represents the output of the function when all inputs except those in the subset S are masked
(2) Shapely values are a linear function of the vector of values f_x(S) generated by enumerating all possible subsets S
(3) kernel SHAP (which is doing weighted linear regression) also produces an answer that is linear in the vector of all output values f_x(S)
(4) therefore, if the linear function in both cases is the same, then kernel SHAP is computing the Shapely values.
Based on this understanding, I expected the computational proof (which was performed for functions of up to 10 inputs) to check whether the final coefficients applied to the vector of output values when analytically solving kernel SHAP were the same as the coefficients used in the classic Shapely value computation. In other words, to use the standard formula for weighted linear regression, the final coefficients for kernel SHAP would be the matrix (X^T W X)^{-1} X^T W where X is a binary matrix in which the rows enumerate all possible subsets S and W are the weights computed by the shapely kernel; I expected the ith row of this matrix to match the coefficients for each S in the equation at the top of the page.
However, it appears that the code for the computational proof is not comparing any coefficients; rather, for a *specific* model generated by the method single_point_model, it compares the final Shapely values produced by kernel SHAP to the values produced by the classic Shapely value computation. Specifically, the code checks that there is negligible difference between kernel_vals and classic_vals, but classic_vals is returned by the method classic_shapely which accepts as one of its arguments a specific model f and returns the shapely values. The code also calls several methods for which the source has not been provided (namely single_point_model, rawShapely, and kernel_shapely).
The statement that SHAP values are a superior form of model explanation is contentious. The authors provide examples in Figure 4 where the SHAP values accord perfectly with human intuition for assigning feature importance, but it is also possible to devise examples where this might not be the case - for example, consider a filter in a convolutional neuron network which has a ReLU activation and a negative bias. This filter produces a positive output when it sees a sufficiently good match to some pattern and an output of zero otherwise. When the neuron produces an output of zero, a human might assign zero importance to all the pixels in the input because the input as a whole did not match the desired pattern. However, SHAP values may assign positive importance to those pixels which resemble the desire pattern and negative importance to the rest - in other words, it might assign nonzero importance to the input pixels even when the input is white noise.
In a similar vein, the argument to favor kernel SHAP over LIME would be more compelling if a comparison with LIME were included in Figure 5. The authors state that didn't do the comparison because the standard implementation of LIME uses superpixel segmentation which is not appropriate here. However, I understand that kernel SHAP and LIME are identical except for the choice of weighting kernel, so I am confused why the authors were not able to adapt their implementation of kernel SHAP to replicate LIME. Some discussion of runtime or the recommended number of function evaluations would have been desirable; the primary reason LIME uses superpixel segmentation for images is to reduce computational cost, and a key advantage of DeepLIFT-style backpropagation is computational efficiency.
The authors show a connection between DeepLIFT and the SHAP values which has already been used by the authors of DeepLIFT to justify improvements to their method. However, the section on Deep SHAP is problematic. The authors state that "Since the SHAP values for the simple components of the network can be analytically solved efficiently, this composition rule enables a fast approximation of values for the whole model", but they explicitly discuss only 2 analytical solutions: Linear SHAP and Max SHAP. Linear SHAP results in idential backpropagation rules for linear components as original DeepLIFT. As explained earlier, the algorithm for Max SHAP proposed in the supplement appears to be incorrect. The authors mention Low-order SHAP and state that it can be solved efficiently, but Low-order SHAP is not appropriate for many neural networks as individual neurons can have thousands of inputs, and even in the case where a neuron has very few inputs it is unclear if the weighted linear regression can be implemented on a GPU in a way that would not significantly slow down the backpropagation (the primary reason to use DeepLIFT-style backpropagation is computational efficiency).
Despite these problems, I feel that the adaptation of Shapely values to the task of model interpretation, as well as the development of kernel SHAP, are substantive enough to accept this paper.
REVISED REVIEW: The authors have addressed my concerns and corrected the issues.


Max-Margin Invariant Features from Transformed Unlabeled Data
The study of representations invariant to common transformations of the data is important to learning. Most techniques have focused on local approximate invariance implemented within expensive optimization frameworks lacking explicit theoretical guarantees. In this paper, we study kernels that are invariant to a unitary group while having theoretical guarantees in addressing the important practical issue of unavailability of transformed versions of labelled data. A problem we call the Unlabeled Transformation Problem which is a special form of semisupervised learning and one-shot learning. We present a theoretically motivated alternate approach to the invariant kernel SVM based on which we propose MaxMargin Invariant Features (MMIF) to solve this problem. As an illustration, we design an framework for face recognition and demonstrate the efficacy of our approach on a large scale semi-synthetic dataset with 153,000 images and a new challenging protocol on Labelled Faces in the Wild (LFW) while out-performing strong baselines.

#### Paper summary
This paper considers the problem of learning invariant features for
classification under a special setting of the more general semi-supervised
learning; focusing on the face recognition problem. Given a set of unlabeled
points (faces), and a set of labeled points, the goal is to learn to construct
a feature map which is invariant to nuisance transformations (as observed
through the unlabeled set i.e., minor pose variations of the same unlabeled
subjects), while being discriminative to the inter-class transformations (as
observed through the labeled sample). The challenge in constructing such an
invariant feature map is that each face in the labeled set is not associated
with an explicit set of possible facial variations. Rather, these minor facial
variations (to be invariant to) are in the unlabeled set.
The paper addresses the problem by appealing to tools from group theory. Each
nuisance transformation is represented as a unitary transformation, and the
set of all nuisance transformations is treated as a unitary group (i.e., set of
orthogonal matrices). Key in constructing invariant features is the so called
"group integration" i.e., integral of all the orthogonal matrices in the group,
resulting in a symmetric projection matrix. This matrix is used to project
points to the invariant space. The paper gives a number of theoretical results
regarding this matrix, and extends it to reproducing kernel Hilbert spaces
(RKHSs). The invariant features, termed *max-margin invariant features* (MMIF),
of a point x are given by taking invariant inner products (induced by the
matrix) in an RKHS between x and a set of unlabeled points.
##### Review summary
The paper contributes a number of theorems regarding the group integration, as
well as invariance in the RKHS. While parts of these can be derived easily, the
end result of MMIFs which are provably invariant to nuisance transformations
is theoretically interesting. Some of these results appear to be new. Notations used
and writing in the paper are unfortunately unclear in many parts. The use of
overloaded notation severely hinders understanding (more comments below). A few
important aspects have not been addressed, including why the MMIFs are
constructed the way they are, and the assumption that "all" unitary
transformations need to be observed (more details below). Computational
complexity of the new approach is not given.
##### Major comments/questions
I find the MMIFs and the presented theoretical results very interesting.
However, there are still some unclear parts which I hope the authors can
address. In order of priority,
1. What is the relationship of the new invariant features to the mean embedding
features of Raj et al., 2017?
Local Group Invariant Representations via Orbit Embeddings
Raj et al., 2017
AISTATS 2017
2. The central part of the proposal is the group integration, integrating over
"all" orthogonal matrices. There is no mentioning at all how this is computed
until the very end on the last page (line 329), from which I infer that the
integration is replaced by an empirical average over all observed unlabeled
points. When the integration is not over all orthogonal matrices in the group,
all the given theorems do not hold. What can we say in this case? Also, how do
we know that the observed unlabeled samples are results of some orthogonal
transform? Line 160 does mention that "small changes in pose can be modeled as
unitary transformations" according to reference [8]. Could you please point out
where in [8]?
3. I understand how the proposed approach creates invariance to nuisance
transformations. What is unclear to me is the motivation of doing the
operations in Eq. (2) and line 284 to create features which are discriminative
for classification. Why are features constructed in this way a good choice for
being discriminative to between-class transformations? Related, at line 274,
the paper mentions about generating random binary label assignments for
training. Why random? There is not enough explanation in the text. Could
you please explain?
4. The size of the invariant feature map in the end is the same as the number
of classes (line 284). However, before obtaining this, an intermediate step in
Eq. (2) requires computing a feature vector of size M for each x (input point),
where M = number of distinct subjects in the unlabeled set. Presumably M must
be very large in practice. What is the runtime complexity of the full
algorithm?
5. In Theorem 2.4, the paper claims that the newly constructed transformation
g_H is a unitary transformation (preserving inner product) in the RKHS H.
However, it appears that only the range of feature map is considered in the
proof i.e., the set R := {x | \phi(x) for x in domain of X} and \phi is the
feature map associated with the kernel. In general, R is a subset (or equal) of
H. The proof of this theorem in the appendix is not complete unless it mentions
how to extend the results of the group transformation on R to H.
6. I think Lemma 2.1 requires the group \mathcal{G} to have linear operation.
So, not "any" group as stated?
##### Suggestions on writing/notations
* \mathcal{X}, \mathcal{X}_\mathcal{G} are overloaded each with 2-3
definitions. See for example lines 119-125. This is very confusing.
* Line 280: K appears out of nowhere. I feel that it should be the number of
classes, which is denoted by N at line 269. But in the beginning N is used to
denote the cardinality of the labeled set...
* The paper should state from the beginning that the Haar measure in Lemma 2.1
will be replaced with an empirical measure as observed through the unlabeled
sample. It will help the reader.
* Line 155: I suggest that the term "generalization" be changed to something
else. As mentioned in the paper itself, the term does not have the usual
meaning.
* There are a few paragraphs that seem to appear out of context. These include
line 85, line 274, line 280 and line 284. Why should the paragraph at line 284
be there? I find it confusing. I feel that lines 311-323 should be in the
introduction.
------- after rebuttal ------
I read the authors' response. The authors partially addressed the issues that
I raised. I have updated the score accordingly.


Maximizing Subset Accuracy with Recurrent Neural Networks in Multi-label Classification
Multi-label classification is the task of predicting a set of labels for a given input instance. Classifier chains are a state-of-the-art method for tackling such problems, which essentially converts this problem into a sequential prediction problem, where the labels are first ordered in an arbitrary fashion, and the task is to predict a sequence of binary values for these labels. In this paper, we replace classifier chains with recurrent neural networks, a sequence-to-sequence prediction algorithm which has recently been successfully applied to sequential prediction tasks in many domains. The key advantage of this approach is that it allows to focus on the prediction of the positive labels only, a much smaller set than the full set of possible labels. Moreover, parameter sharing across all classifiers allows to better exploit information of previous decisions. As both, classifier chains and recurrent neural networks depend on a fixed ordering of the labels, which is typically not part of a multi-label problem specification, we also compare different ways of ordering the label set, and give some recommendations on suitable ordering strategies.

I have been reviewing this paper for another conference, so in my review I mostly repeat my comments sent earlier. Already at that time I was for accepting the paper. It is worth to underline that the paper has been further improved by the authors since then.
The paper considers a problem of solving multi-label classification (MLC) with recurrent neural networks (RNNs). MLC is converted into a sequential prediction problem: the model predicts a sequence of relevant labels. The prediction is made in a sequential manner taking into account all previous labels. This approach is similar to classifier chains, with two key differences: firstly, only single model is used, and its parameters are shared during prediction; secondly, RNN predicts "positive" labels only. In this way, the algorithm can be much more efficient than the standard classifier chains. The authors discuss also the problem of the right ordering of labels to be used during training and testing.
The paper is definitely very investing. The idea of reducing MLC to sequential prediction problem is a natural extension of chaining commonly used for solving MLC under 0/1 loss. I suppose, however, that some similar ideas have been already considered. The authors could, for example, discuss a link between their approach and the learn-to-search paradigm used, for example, in "HC-Search for Multi-Label Prediction: An Empirical Study". I suppose that the algorithm presented in that paper could also be used for predicting sequences of "positive" labels.
Minor comments:
- The authors write that "Our first observation is that PCCs are no longer competitive to the sequence prediction approaches w.r.t. finding the mode of the joint distribution (ACC and maF1)". It seems however that PCC performs better than RNN under the ACC measure.
- FastXML can be efficiently tuned for macro-F (see, "Extreme F-measure Maximization using Sparse Probability Estimates"). It is not clear, however, how much this tuning will improve the result on BioASQ.
After rebuttal:
I thank the authors for their response.


LightGBM: A Highly Efficient Gradient Boosting Decision Tree
Gradient Boosting Decision Tree (GBDT) is a popular machine learning algorithm, and has quite a few effective implementations such as XGBoost and pGBRT. Although many engineering optimizations have been adopted in these implementations, the efficiency and scalability are still unsatisfactory when the feature dimension is high and data size is large. A major reason is that for each feature, they need to scan all the data instances to estimate the information gain of all possible split points, which is very time consuming. To tackle this problem, we propose two novel techniques: Gradient-based One-Side Sampling (GOSS) and Exclusive Feature Bundling (EFB). With GOSS, we exclude a significant proportion of data instances with small gradients, and only use the rest to estimate the information gain. We prove that, since the data instances with larger gradients play a more important role in the computation of information gain, GOSS can obtain quite accurate estimation of the information gain with a much smaller data size. With EFB, we bundle mutually exclusive features (i.e., they rarely take nonzero values simultaneously), to reduce the number of features. We prove that finding the optimal bundling of exclusive features is NP-hard, but a greedy algorithm can achieve quite good approximation ratio (and thus can effectively reduce the number of features without hurting the accuracy of split point determination by much). We call our new GBDT implementation with GOSS and EFB LightGBM. Our experiments on multiple public datasets show that, LightGBM speeds up the training process of conventional GBDT by up to over 20 times while achieving almost the same accuracy.

The paper presents two nice ways for improving the usual gradient boosting algorithm where weak classifiers are decision trees. It is a paper oriented towards efficient (less costful)  implementation of the usual algorithm in order to speed up the learning of decision trees by taking into account previous computations and sparse data.
The approaches are interesting and smart. A risk bound is given for one of the improvements (GOSS), which seems sound but still quite loose: according to the experiments, a tighter bound could be obtained, getting rid of the "max" sizes of considered sets. No garantee is given for the second improvement (EFB) although is seems to be quite efficient in practice.
The paper comes with a bunch of interesting experiments, which give good insights and shows a nice study of the pros and vons of the improving approaches, both in accuracy and computational time, in various types of datasets. The experiments lacks of standard deviation indications, for the performances are often very closed from one mathod to another. A suggestion would be to observe the effect of noise in the data on the improvement methods (especially on GOSS, which relies mostly on a greedy selection based on the highest gradients).
The paper is not easy to read, because the presentation, explanation, experimental study and analysis are spread all over the paper. It would be better to concentrate fully on one improvements, then on the other, and to finish by the study of them together.  Besides, it would be helpfulfor the reader if the main algorithms where written in simplest ways, not in pseudo codes and assumption on the specificities of data structures.


Universal consistency and minimax rates for online Mondrian Forests
We establish the consistency of an algorithm of Mondrian Forests [LRT14, LRT16], a randomized classification algorithm that can be implemented online. First, we amend the original Mondrian Forest algorithm proposed in [LRT14], that considers a fixed lifetime parameter. Indeed, the fact that this parameter is fixed hinders the statistical consistency of the original procedure. Our modified Mondrian Forest algorithm grows trees with increasing lifetime parameters λ n , and uses an alternative updating rule, allowing to work also in an online fashion. Second, we provide a theoretical analysis establishing simple conditions for consistency. Our theoretical analysis also exhibits a surprising fact: our algorithm achieves the minimax rate (optimal rate) for the estimation of a Lipschitz regression function, which is a strong extension of previous results [AG14] to an arbitrary dimension.

Summary:
This paper proposes a modification of Mondorian Forest which is a variant of Random Forest, a majority vote of decision trees. The authors show that the modified algorithm has the consistency property while the original algorithm does not have one. In particular, when the conditional probability function is Lipschitz, the proposed algorithm achieves the minimax error rate, where the lower bound is previously known.
Comments:
The technical contribution is to refine the original version of the Mondorian Forest and prove its consistency. The theoretical results are nice and solid. The main idea comes from the original algorithm, thus the originality of the paper is a bit incremental.
I’m wondering that in Theorem 2, there is no factor about K, the number of Mondrian trees, as authors mentioned in Section 5. In my intuition, it is natural that many K results more accurate and converges faster. Ultimately, Theorem 2 says the Mondrian forest works well even if K=1. Is there any theoretical evidence of advantage by using many Mondrian trees?
 Computational time of Algorithm 4 is not clear. It seems to me that increasing lifetime parameters leads more time consumption in SplitCell.
 In theorem 2, it is natural to measure the difference between two distributions by KL divergence. Do you have any idea of using another discrepancy measure instead of the quadratic loss? Additionally, the proof, the variance of noise \sigma assumed to be a constant. Is it a natural setting?
Minor Comments:
Line 111 g_n(x,Z_k) -> \hat{g}_n(x,Z_k)
Line 117 \nu_{d_\eta} -> \nu_{\eta}
Line 3 of pseudocode of Algorithm 2 \tau_A -> \tau
Line 162 M_{\lambda^{\prime}} \sim MP(\lambda,C) -> M_{\lambda^{\prime}} \sim MP(\lambda^{\prime},C)


Sticking the Landing: Simple, Lower-Variance Gradient Estimators for Variational Inference
We propose a simple and general variant of the standard reparameterized gradient estimator for the variational evidence lower bound. Specifically, we remove a part of the total derivative with respect to the variational parameters that corresponds to the score function. Removing this term produces an unbiased gradient estimator whose variance approaches zero as the approximate posterior approaches the exact posterior. We analyze the behavior of this gradient estimator theoretically and empirically, and generalize it to more complex variational distributions such as mixtures and importance-weighted posteriors.
Recent advances in variational inference have begun to make approximate inference practical in large-scale latent variable models. One of the main recent advances has been the development of variational autoencoders along with the reparameterization trick Welling, 2013, Rezende et al., 2014]. The reparameterization trick is applicable to most continuous latent-variable models, and usually provides lower-variance gradient estimates than the more general REINFORCE gradient estimator [Williams, 1992].
Intuitively, the reparameterization trick provides more informative gradients by exposing the dependence of sampled latent variables z on variational parameters φ. In contrast, the REINFORCE gradient estimate only depends on the relationship between the density function log q φ (z|x, φ) and its parameters.
Surprisingly, even the reparameterized gradient estimate contains the score function-a special case of the REIN-FORCE gradient estimator. We show that this term can easily be removed, and that doing so gives even lower-variance gradient estimates in many circumstances. In particular, as the variational posterior approaches the true posterior, this gradient estimator approaches zero variance faster, making stochastic gradient-based optimization converge and "stick" to the true variational parameters, as seen in figure 1.

The authors analyze the functional form of the reparameterization trick for obtaining the gradient of the ELBO, noting that one term depends on the gradient wrt. the sample z, which they call the path derivative, and the other term does not depend on the gradient wrt sample z, which they (and others) call the score function. The score function has zero expectation, but is not necessarily zero at particular samples of z. The authors propose to delete the score function term from the gradient, and show can be done with a one-line modification in popular autodiff software. They claim that this can reduce the variance—in particular, as the variational posterior approaches the true posterior, the variance in the stochastic gradient approaches zero. They also extent this idea nontrivially to more complicated models.
While this is a useful and easy-to-use trick, particularly in the way it is implemented in autodiff software, this does not appear to be a sufficiently novel contribution. The results about the score function are well-known, and eliminating or rescaling the score function seems like a natural experiment to do.
The discussion of control variates in lines 124-46 is confusing and seemingly contradictory. From my understanding, setting the control variate scale c = 1 corresponds to including the score function term, i.e. using the ordinary ELBO gradient. Their method proposes to not use a control variable, i.e. set c = 0. But lines 140-6 imply that they got better experimental results setting c = 1, i.e. the ordinary ELBO gradient, than with c = 0, i.e. the ELBO gradient without the score function term. This contradicts their experimental results. Perhaps I have misunderstood this section, but I’ve read it several times and still can’t come to a sensible interpretation.
The experimental results show only marginal improvements, though they are essentially free.


Continual Learning with Deep Generative Replay
Attempts to train a comprehensive artificial intelligence capable of solving multiple tasks have been impeded by a chronic problem called catastrophic forgetting. Although simply replaying all previous data alleviates the problem, it requires large memory and even worse, often infeasible in real world applications where the access to past data is limited. Inspired by the generative nature of the hippocampus as a short-term memory system in primate brain, we propose the Deep Generative Replay, a novel framework with a cooperative dual model architecture consisting of a deep generative model ("generator") and a task solving model ("solver"). With only these two models, training data for previous tasks can easily be sampled and interleaved with those for a new task. We test our methods in several sequential learning settings involving image classification tasks.

Quality:
The paper is technically sound. Extensive comparisons between the proposed approach and other baseline approaches are being made.
Clarity:
The paper is well-organized. However, insufficient details are provided on the architectures of the discriminator, generator and the used optimizer.
I would be surprised if the cited papers refer to the hippocampus as a short-term memory system since the latter typically refers to working memroy. I assume they all refer to hippocampus as a system for long-term memory consolidation. I advice to adapt accordingly.
A bit more attention should be paid to English writing style:
primate brain’s the most apparent distinction
inputs are coincided with
Systems(CLS)
Recent evidences
networks(GANs)
A branch of works
line 114:  real and outputs 1/2 everywhere => unclear; please reformulate
line 124:  real-like samples => realistic; real-life (?)
in both function
past copy of a self.
Sequence
of scholar models were
favorable than other two methods
can recovers real input space
Old Tasks Performance
good performances
with in same setting employed in section 4.3.

Originality:
The proposed approach to solve catastrophic forgetting is new (to my knowledge) yet also straightforward, replacing experience replay with a replay mechanism based on a generative model. The authors do show convincingly that their approach performs much better than other approaches, approximating exact replay.
A worry is that the generative model essentially stores the experiences which would explain why its performance is almost identical to that of experience replay. I think the authors need to provide more insight into the how performance scales with data size and show that the generative model becomes more and more memory efficient as the number of processed training samples increases. In other words: the generative model only makes sense if its memory footprint is much lower than that of just storing the examples. I am sure this would be the case but it is important and insightful to make this explicit.
Significance:
The results are important given the current interest in life-long learning. While the idea is expected in the light of current advances, the authors give a convincing demonstration of the usefulness of this approach. If the authors can improve the manuscript based on suggested modifications then I believe the paper would be a valuable contribution.


A Minimax Optimal Algorithm for Crowdsourcing
We consider the problem of accurately estimating the reliability of workers based on noisy labels they provide, which is a fundamental question in crowdsourcing. We propose a novel lower bound on the minimax estimation error which applies to any estimation procedure. We further propose Triangular Estimation (TE), an algorithm for estimating the reliability of workers. TE has low complexity, may be implemented in a streaming setting when labels are provided by workers in real time, and does not rely on an iterative procedure. We prove that TE is minimax optimal and matches our lower bound. We conclude by assessing the performance of TE and other state-of-the-art algorithms on both synthetic and real-world data.

Summary of paper:
The authors derive a lower bound on estimating crowdsource worker reliability in labeling data.  They then propose an algorithm to estimate this reliability and analyze the algorithm’s performance.
Summary of review:
This submission presents a solid piece of research that is well-grounded in both theory and application.
Detailed review:
—
Quality:
This paper is thorough.  The lower bound and relevant proofs are outlined cleanly.  The algorithm is presented in conjunction with time and memory complexity analysis, and the authors compare to related work nicely.  Both simulated and real data sets are used; the simulated data have multiple settings and six sources of real-world data are used.  The experiments do not demonstrate that the proposed algorithms outperforms all competing methods, but these results are refreshingly realistic and provide a compelling argument for the use of the proposed algorithm.
—
Clarity:
The paper is well-written; the problem and contributions are outlined clearly.  The paper would benefit from more description regarding the intuitions of TE and perhaps a high-level summary paragraph in the numerical experiments section.
—
Originality:
The proposed algorithm is novel and the derived lower bound is tied nicely to the problem, bringing a rare balance of theory and application.
—
Significance:
While the problem addressed is very specific, it is important.  The proposed algorithm does well—even if it doesn’t beat all others in every instance, it’s more consistent in its performance.  This paper will be a solid contribution to the crowdsourcing literature, and could easily impact the use of crowdsourced labels as well.


VEEGAN: Reducing Mode Collapse in GANs using Implicit Variational Learning
Deep generative models provide powerful tools for distributions over complicated manifolds, such as those of natural images. But many of these methods, including generative adversarial networks (GANs), can be difficult to train, in part because they are prone to mode collapse, which means that they characterize only a few modes of the true distribution. To address this, we introduce VEEGAN, which features a reconstructor network, reversing the action of the generator by mapping from data to noise. Our training objective retains the original asymptotic consistency guarantee of GANs, and can be interpreted as a novel autoencoder loss over the noise. In sharp contrast to a traditional autoencoder over data points, VEEGAN does not require specifying a loss function over the data, but rather only over the representations, which are standard normal by assumption. On an extensive set of synthetic and real world image datasets, VEEGAN indeed resists mode collapsing to a far greater extent than other recent GAN variants, and produces more realistic samples.

This paper proposes a variation of the GAN algorithm aimed at improving the mode coverage of the generative distribution.
The main idea is to use three networks: a generator, an encoder and a discriminator where the discriminator takes pairs (x,z) as input.
The criterion to optimize is a GAN style criterion for the discriminator and a reconstruction in latent space for the encoder (unlike
auto-encoders where the reconstruction is in input space).
The proposed criterion is properly motivated and experimental evidence is provided to support the claim that
the new criterion allows to produce good quality samples (similarly to other GAN approaches) but with more diversity and coverage
of the target distribution (i.e. more modes are covered) than other approaches.
The results are fairly convincing and the algorithm is evaluated with several of the metrics used in previous literature on missing modes in generative models.
However, I believe that the paper could be improved on two aspects:
- the criterion is only partially justified by the proposed derivation starting from the cross entropy in Z space and there is an extra distance
term that is added without clear justification (it's ok to add terms, but making it sound like it falls out of the derivation is not great)
- the connection to other existing approaches, and in particular ALI could be further detailed and the differences could be better explained.
More specifically, regarding section 3.1 and the derivation of the objective, I think the exposition is somewhat obfuscating what's really going on:
Indeed, I would suggest to rewrite (3) as the following simple lemma:
H(Z,F_\theta(X)) <= KL(q_\gamma(x|z)p_0(z) \| p_\theta(z|x)p(x)) - E log p_0(z)
which directly follows from combining (1) and (2)
And then the authors could argue that they add this extra expected distance term (third term of (3)).
But really, this term is not justified by any of the derivation. However, it is important to notice that this term vanishes exactly
when the KL term is minimized since the minimum of the KL term is reached when q_\gamma inverses p_\theta i.e. when F_\theta
is the inverse of G_\gamma in which case z=F_\theta(G_\gamma(z)).
There is also the question of whether this term is necessary.
Of course, it helps training the encoder to invert the decoder but it seems possible to optimize only the first part of (5) with
respect to both theta and gamma
Regarding the connection to ALI: the discriminator is similar to the one in ALI and trained with the same objective. However what is different
is the way the discriminator is used when training the generator and "encoder" networks. Indeed, in ALI they are trained by optimizing
the JS divergence, while here the generator is trained by optimizing the (estimate of) KL divergence plus the additional reconstruction term and the encoder is purely trained using the reconstruction term.
It would be interesting to see what is the effect of varying the weight of the reconstruction term. The authors say that there is no need
to add a weight (indeed, the reconstruction term is zero when the KL term is zero as discussed above), but that doesn't mean it cannot have
an effect in practice.
Side note: there is inconsistency in the notations as d is a distance in latent space, so d(z^i, x_g^i) is not correct and should be
replaced by d(z^i, F_\theta(x_g^i)) everywhere.
Overall, I feel that this paper presents an interesting new algorithm for training a generative model and the experiments are showing that
it does have the claimed effect of improving the mode coverage of other comparable algorithms, but the derivation and justification of the
algorithm as well as the comparison to other algorithms could be improved in order to provide better intuition of why this would work.


GP CaKe: Effective brain connectivity with causal kernels
A fundamental goal in network neuroscience is to understand how activity in one brain region drives activity elsewhere, a process referred to as effective connectivity.
Here we propose to model this causal interaction using integro-differential equations and causal kernels that allow for a rich analysis of effective connectivity. The approach combines the tractability and flexibility of autoregressive modeling with the biophysical interpretability of dynamic causal modeling. The causal kernels are learned nonparametrically using Gaussian process regression, yielding an efficient framework for causal inference. We construct a novel class of causal covariance functions that enforce the desired properties of the causal kernels, an approach which we call GP CaKe. By construction, the model and its hyperparameters have biophysical meaning and are therefore easily interpretable. We demonstrate the efficacy of GP CaKe on a number of simulations and give an example of a realistic application on magnetoencephalography (MEG) data.

This paper addresses the problem of understanding brain connectivity (i.e. how activity in one region from the brain drives activity in other regions) from brain activity observations. More generally, perhaps, the paper attempts to uncover causal structure and uses neuroscience insights to specifically apply the model to brain connectivity. The model can be seen as an extension of (linear) dynamic causal models (DCMs) and assumes that the observations are a linear combination of latent activities, which have a GP prior, plus Gaussian noise (Eq 11).
Overall the paper is readable but more clarity in the details of how the posterior over the influence from i->j is actually computed (paragraph just below Eq 12).
I write this review as a machine learning researcher (i.e. non-expert in neuroscience) so I am not entirely sure about the significance of the contribution in terms of neuroscience. For the machine learning perspective, the paper does not really provide a significant contribution as it applies standard GP regression. Indeed, it seems that the claimed novelty arises from the specific kernel used in order to incorporate localization, causality, and smoothness. However, none of these components seem actually new as they use, respectively, (i) the squared exponential (SE) covariance function, (iii) a previously published kernel, and (iii) some additional smoothing also previously known. With this regards, it is unclear why this additionally smoothing is necessary as the SE kernel is infinitely differentiable.
The method is evaluated on a toy problem and on a real dataset. There are a couple of major deficiencies in the approach from the machine learning (ML) perspective. Firstly, the mixing functions are assumed to be known. This is very surprising as these functions will obviously have an important effect on the predictions. Second, for the only real dataset used, most (if not all) the hyperparameters are fixed, which also goes against standard ML practice. These hyperparameters are very important, as shown in the paper for the toy dataset, and ultimately affect the connectivities discovered.
There also seems to be a significant amount of pre-processing to actually fit the problem to the method, for example, as explained in section 5, running ICA. It is unclear how generalizable such an approach would be in practice.


Optimal Shrinkage of Singular Values Under Random Data Contamination
A low rank matrix X has been contaminated by uniformly distributed noise, missing values, outliers and corrupt entries. Reconstruction of X from the singular values and singular vectors of the contaminated matrix Y is a key problem in machine learning, computer vision and data science. In this paper, we show that common contamination models (including arbitrary combinations of uniform noise, missing values, outliers and corrupt entries) can be described efficiently using a single framework. We develop an asymptotically optimal algorithm that estimates X by manipulation of the singular values of Y , which applies to any of the contamination models considered. Finally, we find an explicit signal-to-noise cutoff, below which estimation of X from the singular value decomposition of Y must fail, in a welldefined sense.

This paper consider the problem of matrix de-noising under the mean square-loss via estimators that shrink the singular values of a contaminated version of the matrix to be estimated. Specifically, the authors seek asymptotically optimal shrinkers under various random contamination models, extending beyond additive white noise.
Unfortunately, I could not determine the novelty of the techniques used as there is no clear indication in the paper of what results are new or rather simple extensions of previous results, such as in Nadakuditi (2014) and Gavish & Donoho (2017). As a non-expert, as far as I can see, the results in this paper are rather simple extensions of those given in Gavish and Donoho. A clear indication of what is new and a detailed comparison to what is already known is needed. In addition, I found many sentences to be unclear and inadequate, making it a difficult read.
Some more specific questions/comments:
In line 213 it is not clear whether you prove that the a.s. limit exists or assume it exists.
It is unclear under what class of estimators is yours optimal. Only a clue is given in the very last sentence of the paper.
In line 64, the variance of A's entries is taken to be the same as that of B, namely \sigma_B, while later it is changed to sigma_A. Thm. 2 however does not involve sigma_A. Is there a specific reason for choosing sigma_B = sigma_A?
In addition, it is unclear how can one estimate mu_A, sigma_A and sigma_B, which are needed for the method.
Lines 89 and 90 should come before Thm. 1.
The hard threshold shrinker is missing a multiplicative y_i all over the paper.
There are many typos.


Multiscale Quantization for Fast Similarity Search
We propose a multiscale quantization approach for fast similarity search on large, high-dimensional datasets. The key insight of the approach is that quantization methods, in particular product quantization, perform poorly when there is large variance in the norms of the data points. This is a common scenario for realworld datasets, especially when doing product quantization of residuals obtained from coarse vector quantization. To address this issue, we propose a multiscale formulation where we learn a separate scalar quantizer of the residual norm scales. All parameters are learned jointly in a stochastic gradient descent framework to minimize the overall quantization error. We provide theoretical motivation for the proposed technique and conduct comprehensive experiments on two large-scale public datasets, demonstrating substantial improvements in recall over existing state-of-the-art methods.

The paper proposes a novel approach to reduce quantization error in the scenario where the product quantization is applied to the residual values that are the result of the coarse whole-space quantization. To encode residuals the authors propose to (1) quantize the norm separately (2) apply product quantization to unit-normalized residuals. It trains everything in the end-to-end manner, which is certainly good.
Pros:
1. I very much like the approach.
2. The paper is well-written.
3. A good coverage of work related to quantization (including several relevant recent papers). However, not all work related to efficient k-NN search (see below)!
Cons:
1. The related work on non-quantization techniques doesn't mention any graph-based techniques. Compared to quantization approaches they are less SPACE-efficient (but so are LSH methods, even more so!), but they are super-fast. Empirically they often greatly outperform everything else, in particular, they outperform LSH.
One recent relevant work (but there are many others): Harwood, Ben, and Tom Drummond. "FANNG: fast approximate nearest neighbour graphs." Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition. 2016.
I would encourage authors to mention this line of work, space permitting.
2. The paper is a bit cryptic. See, e.g., my comment to the recall experiments section.
A few more detailed comments:
I think I can guess where formula 4:158 comes from, but it won't harm if you show a derivation.
7: 280 What do you mean by saying that VPSHUFB performs lookups? It's a shuffle instruction, not a store/gather instruction.
Recall experiments: Does the phrase "We generate ground-truth results using brute force search, and compare the
results of each method against ground-truth in fixed-bitrate settings." mean that you do not compute accuracy for the k-NN search using *ORIGINAL* vectors? Please, also clarify how do you understand ground-truth in the fixed-bitrate setting.
Figure 4: please, explain better the figures. I don't quite get what is exactly the number of neighbors on x axis. Is this the number of neighbors retrieved using an approximated distance, i.e., using the formula in 4:158?
Speed benchmarks are a bit confusing, because these are only for sequential search using a tiny subset of data likely fitting into a L3 cache. I would love to see actually full-size tests.
Regarding the POPCNT approach: what exactly do you do? Is it a scalar code? Is it single-thread? I am asking b/c I am getting twice as longer processing times using POPCNT for the Hamming distance with the same number of bits (128).
What is your hardware: CPU, #of cores, RAM, cache size? Are your speed-benchmarks single-threaded?
Which compiler do you use?
Please, clarify if your approach to learning an orthogonal transformation (using Cayley factorization) is novel or not.


Asynchronous Parallel Coordinate Minimization for MAP Inference
Finding the maximum a-posteriori (MAP) assignment is a central task for structured prediction. Since modern applications give rise to very large structured problem instances, there is increasing need for efficient solvers. In this work we propose to improve the efficiency of coordinate-minimization-based dual-decomposition solvers by running their updates asynchronously in parallel. In this case messagepassing inference is performed by multiple processing units simultaneously without coordination, all reading and writing to shared memory. We analyze the convergence properties of the resulting algorithms and identify settings where speedup gains can be expected. Our numerical evaluations show that this approach indeed achieves significant speedups in common computer vision tasks.

SUMMARY:
========
The authors propose a parallel MAP inference algorithm based on a dual decomposition of the MAP objective.  Updates are performed without synchronization and locally enforce consistency between overlapping regions.  A convergence analysis establishes a linear rate of convergence and experiments are performed on synthetic MRFs and image disparity estimation.
PROS:
=====
The paper is well-rounded and provides algorithmic development, theoretical analysis in terms of convergence rate results, and experimental validation.  Clarity is good overall and the work is interesting, novel, and well-motivated.
CONS:
=====
Experimental validation in the current paper is inadequate in several respects.  First, since the approach is posed as a general MAP inference it would be ideal to see validation in more than one synthetic and one real world model (modulo variations in network topology).  Second, the size of problem instances is much too small to validate a "large-scale" inference algorithm.  Indeed, as the authors note (L:20-21) a motivation of the proposed approach is that "modern applications give rise to very large instances".  To be clear, the "size" of instances in this setting is the number of regions in Eq. (1).  The largest example is on image disparity, which contains less than 27K regions.  By contrast, the main comparison, HOGWILD, was originally validated on three standard "real world" instances with a number of objective terms reaching into the millions.  Note that even single-threaded inference converges within a few hundred seconds in most cases.  Finally, the authors do not state which disparity estimation dataset and model are used.  This reviewer assumes the standard Middlebury dataset it used, but the reported number of regions is much smaller than the typical image size in that dataset, please clarify.
Results of the convergence analysis are not sufficient to justify the lack of experimental validation.  In particular, Theorem 1 provides a linear rate of convergence, but this does not establish global linear rate of convergence as the bound is only valid away from a stationary point (e.g. when the gradient norm is above threshold).  It is also unclear to what extent assumptions of the convergence rate can be evaluated since they must be such that the delay rate, which is unknown and not controlled, is bounded above as a function of c and M.  As a secondary issue, this reviewer is unclear about the sequential results.  Specifically, it is not clear why the upper bound in Prop. 2 is necessary when an exact calculation in Prop. 1 has been established, and as the authors point out this bound can be quite loose.  Also, it is not clear what the authors mean when they state Prop. 2 accounts for the sparsity of updates.  Please clarify.


Multi-output Polynomial Networks and Factorization Machines
Factorization machines and polynomial networks are supervised polynomial models based on an efficient low-rank decomposition. We extend these models to the multi-output setting, i.e., for learning vector-valued functions, with application to multi-class or multi-task problems. We cast this as the problem of learning a 3-way tensor whose slices share a common basis and propose a convex formulation of that problem. We then develop an efficient conditional gradient algorithm and prove its global convergence, despite the fact that it involves a non-convex basis selection step. On classification tasks, we show that our algorithm achieves excellent accuracy with much sparser models than existing methods. On recommendation system tasks, we show how to combine our algorithm with a reduction from ordinal regression to multi-output classification and show that the resulting algorithm outperforms simple baselines in terms of ranking accuracy.

The authors extend factorization machines and polynomial networks to the multi-output setting casting their formulation as a 3-way tensor decomposition. Experiments on classification and recommendation are presented.
I enjoyed reading the paper and although the model itself seems a somewhat incremental extension with respect to [5], the algorithmic approach is interesting and the theoretical results are welcome.
I would like to see runtimes of the proposed model compared to baselines, kernelized in particular, to highlight the benefits of the proposed method. Besides, the classification experiments could use at least one large dataset, the largest used is letter (N=15,000), again it will serve to highlight the benefits of the proposed model.
I understand that a polynomial SVM with quadratic kernel is a natural baseline for the proposed model but I am curious about the results with more popular kernels choices, i.e, 3rd degree polynomial or RBF.
The recommender system experiment needs baselines to put the results from single-output and ordinal McRank FMs in context.
Minor comments:
- line 26, classical approaches such as?


Practical Data-Dependent Metric Compression with Provable Guarantees
We introduce a new distance-preserving compact representation of multidimensional point-sets. Given n points in a d-dimensional space where each coordinate is represented using B bits (i.e., dB bits per point), it produces a representation of size O(d log(dB/ ) + log n) bits per point from which one can approximate the distances up to a factor of 1 ± . Our algorithm almost matches the recent bound of [6] while being much simpler. We compare our algorithm to Product Quantization (PQ) [7], a state of the art heuristic metric compression method. We evaluate both algorithms on several data sets: SIFT (used in [7]), MNIST [11], New York City taxi time series [4] and a synthetic one-dimensional data set embedded in a high-dimensional space. With appropriately tuned parameters, our algorithm produces representations that are comparable to or better than those produced by PQ, while having provable guarantees on its performance.

This paper presents an impressive algorithm that embeds a set of data points into a small dimensional space, represented by a near-optimal number of bits. The most appealing aspect of this paper is to provide a simple but provable dimensionality reduction algorithm, and supported by empirical experiments.
=== Strengths ===
This paper is supported by strong theoretical analysis. And, it is much simpler algorithm than [5] with a slightly worse bit complexity.
=== Weaknesses ===
1. This is an example of data-dependent compression algorithm. Though this paper presents a strong theoretical guarantee, it needs to be compared to state-of-the art data-dependent algorithms. For example,
 - Optimized Product Quantization for Approximated Nearest Neighbor Search, T. Ge et al, CVPR’13
 - Composite Product Quantization for Approximated Nearest Neighbor Search, T. Zhang et al, ICML’14
 - And, other recent quantization algorithms.
2. The proposed compression performs worse than PQ when a small code length is allowed, which is the main weakness of this method, in view of a practical side.
3. When the proposed compression is allowed to have the same bit budget to represent each coordinate, the pairwise Euclidean distance is not distorted? Most of compression algorithms (not PCA-type algorithms) suffer from the same problem.
=== Updates after the feedback ===
I've read other reviewers' comments and authors' feedback. I think that my original concerns are resolved by the feedback. Moreover, they suggest a possible direction to combine QuadSketch with OPQ, which is appealing.


Stein Variational Gradient Descent as Gradient Flow
Stein variational gradient descent (SVGD) is a deterministic sampling algorithm that iteratively transports a set of particles to approximate given distributions, based on a gradient-based update that guarantees to optimally decrease the KL divergence within a function space. This paper develops the first theoretical analysis on SVGD. We establish that the empirical measures of the SVGD samples weakly converge to the target distribution, and show that the asymptotic behavior of SVGD is characterized by a nonlinear Fokker-Planck equation known as Vlasov equation in physics. We develop a geometric perspective that views SVGD as a gradient flow of the KL divergence functional under a new metric structure on the space of distributions induced by Stein operator.

–––RESPONSE TO AUTHOR REBUTTAL––––
The author's response is very thoughtful, but unfortunately it doesn't fully address my concerns.
The fact that the proof of Lemma 3.1 works in the compact case is fine as far as it goes, but substantially detracts from how interesting the result is. The proposed condition on E_{y\sim \mu}[max_x(g(x,y))] is not sufficient since the same condition also has to hold for mu', which is a much more challenging condition to guarantee uniformly. It seems such a condition is also necessary in a Wasserstein metric version of Lemma 3.1. So the fix is non-trivial.
The changes to Theorem 3.3 are more straightforward.
Another issue which I forgot to include in my review  is that the empirical measure converges in BL at a n^{-1/d} + n^{-1/2} rate, not the n^{-1/2} rate claimed at line 133. See [1] and [2].
Overall the paper requires substantial revision as well as some new technical arguments. I still recommend against acceptance.
[1] Sriperumbudur et al. On the empirical estimation of integral probability metrics. Electron. J. Statist. Volume 6 (2012), 1550-1599.
[2] Fournier and Guillin. On the rate of convergence in Wasserstein distance of the empirical measure. Probability Theory and Related Fields. Volume 162, Issue 3–4 (2015), pp 707–738.
–––ORIGINAL REVIEW–––
Summary: The paper investigates theoretical properties of Stein variational gradient descent (SVGD). The paper provides asymptotic convergence results, both in the large-particle and large-time limits. The paper also investigates the continuous-time limit of SVGD, which results in a PDE that has the flavor of a deterministic Fokker-Planck equation. Finally, the paper offers a geometric perspective, interpreting the continuous-time process as a gradient flow and introducing a novel optimal transport metric along the way.
Overall, this is a very nice paper with some insightful results. However, there are a few important technical issues that prevent me from recommending publication.
1. Theorem 3.2: Via Lemma 3.1, Theorem 3.2 assumes g(x,y) is bounded and Lipschitz. However, if p is distantly dissipative, then g(x,y) is not bounded. Thus, the result as stated is essentially vacuous. That said, examining the proof, it should be straightforward to replace all of the bounded Lipschitz norms with Lipschitz norms and then get a result in terms of Wasserstein distance while only assuming g(x, y) is Lipschitz.
2. On a related note, the fact that the paper assumes eq. (7) holds “without further examination” (lines 78-79) seems ill-advised. As can be seen from the case of Theorem 3.2, it is important to validate that the hypotheses of a result actually hold and don’t interact badly with other (implicit) assumptions. The author(s) should more thoroughly discuss and show that the hypotheses in the two main theorems actually hold in some non-trivial cases.
3. Theorem 3.3: The final statement of the theorem, that eq. (12) implies the stein discrepancy goes to zero as \ell -> infinity, is not true. In particular, if \epsilon_\ell^* goes to zero too quickly, there’s no need for the Stein discrepancy to go to zero. Again, I think this statement can also be shown rigorously using the upper bound on the spectral radius discussed in the first remark after Thm 3.3. However, this should be worked out by the author(s).
Minor comments:
- \rho is never defined in Thm 3.3
- In many results and remarks: instead of writing “Assume …, then …”, one should writing either “Assuming …, then …” or “If …, then …”.
- There were numerous other grammatical errors
- \phi_{\mu,p}^* was used inconsistently: sometimes it was normalized to have norm 1, sometimes it wasn’t.
- The references need to be updated: many of the papers that are only cited as being on the arXiv have now been published


Deconvolutional Paragraph Representation Learning
Learning latent representations from long text sequences is an important first step in many natural language processing applications. Recurrent Neural Networks (RNNs) have become a cornerstone for this challenging task. However, the quality of sentences during RNN-based decoding (reconstruction) decreases with the length of the text. We propose a sequence-to-sequence, purely convolutional and deconvolutional autoencoding framework that is free of the above issue, while also being computationally efficient. The proposed method is simple, easy to implement and can be leveraged as a building block for many applications. We show empirically that compared to RNNs, our framework is better at reconstructing and correcting long paragraphs. Quantitative evaluation on semi-supervised text classification and summarization tasks demonstrate the potential for better utilization of long unlabeled text data.

This paper proposes encoder-decoder models that uses convolutional neural networks, not RNNs. Experimental results on NLP data sets show that the proposed models outperform several existing methods.
In NLP, RNNs are more commonly used than CNNs. This is because the length of an input varies. CNNs can only handle a fixed length of an input, by truncating input text or padding shortage of the input. In experiments, it is okay to assume the length of an input, such as 50-250 words; however, in reality, we need to handle an arbitrary length of text information, sometimes 10 and sometimes 1,000 words. In this respect, RNNs, especially, LSTMs, have high potential in NLP applications.
Major Comments:
1. For summarization experiments, Document Understanding Conference (DUC) data sets and CNN news corpus are commonly used.
2. For the headline summarization, if you use shared data, we can judge how your models are better than other methods, including non-neural approaches.
3. Table 2 shows that the CNN-DCNN model can directly output an input. Extremely high BLEU scores imply low generalization. It has a sufficient rephrasing ability, it cannot achieve the BLUE scores over 90.
4. In image processing, similar models have already been proposed, such as:
V. Badrinarayanan, A. Handa, and R. Cipolla. SegNet: a deep convolutional encoder-decoder architecture
for robust semantic pixel-wise labelling. arXiv preprint
arXiv:1505.07293, 2015.
Please make your contributions clear in your paper.
5. I am not sure how your semi-supervised experiments have been conducted. In what sense, your methods are semi-supervised?
6. Regarding the compared LSTM-LSTM encoder-decoder model, is it an attention-based encoder-decoder model?
7. I suggest to try machine translation data sets, in your future work.


Population Matching Discrepancy and Applications in Deep Learning
A differentiable estimation of the distance between two distributions based on samples is important for many deep learning tasks. One such estimation is maximum mean discrepancy (MMD). However, MMD suffers from its sensitive kernel bandwidth hyper-parameter, weak gradients, and large mini-batch size when used as a training objective. In this paper, we propose population matching discrepancy (PMD) for estimating the distribution distance based on samples, as well as an algorithm to learn the parameters of the distributions using PMD as an objective. PMD is defined as the minimum weight matching of sample populations from each distribution, and we prove that PMD is a strongly consistent estimator of the first Wasserstein metric. We apply PMD to two deep learning tasks, domain adaptation and generative modeling. Empirical results demonstrate that PMD overcomes the aforementioned drawbacks of MMD, and outperforms MMD on both tasks in terms of the performance as well as the convergence speed.

This paper presents the population matching discrepancy (PMD) as a better alternative to MMD for distribution matching applications.  It is shown that PMD is a sampled version of Wasserstein metric or earth mover’s distance, and it has a few advantages over MMD, most notably stronger gradients and the applicability of smaller mini-batch sizes, and fewer hyperparameters.
For training generative models at least, the MMD metric does suffer from weak gradients and the requirement of large mini-batches, the proposals in this paper therefore provides a nice solution to both of these problems.  The small mini-batch claim is verified quite nicely in the empirical results.  The verification of the stronger gradients claim is less satisfactory, since the MMD metric depends on the scale parameter sigma, it is essential to consider either the best sigma or a range of sigmas when making such a claim.
In terms of having fewer hyper-parameters, I feel this claim is less well-supported, because PMD depends on a distance metric, and this distance metric might contain extra hyperparameters as well as in the MMD case.  Moreover, it is hard to get a reliable distance metric in a high dimensional space, therefore PMD may suffer from the same issue of relying on a distance metric as MMD.  On the other hand, there are some standard heuristics for MMDs about how to choose the bandwidth parameter, it would be good to compare against such heuristics and treat MMD as a hyperparameter-free metric as well.
Overall I think the proposed method has the nice property of permitting small minibatch sizes therefore fast training.  It seems like a valid improvement over large batch MMD methods.  But the it still has the problem of relying on a distance metric, which may limit its success on modeling higher dimensional data.


Stabilizing Training of Generative Adversarial Networks through Regularization
Deep generative models based on Generative Adversarial Networks (GANs) have demonstrated impressive sample quality but in order to work they require a careful choice of architecture, parameter initialization, and selection of hyper-parameters. This fragility is in part due to a dimensional mismatch or non-overlapping support between the model distribution and the data distribution, causing their density ratio and the associated f -divergence to be undefined. We overcome this fundamental limitation and propose a new regularization approach with low computational cost that yields a stable GAN training procedure. We demonstrate the effectiveness of this regularizer accross several architectures trained on common benchmark image generation tasks. Our regularization turns GAN models into reliable building blocks for deep learning.

This paper proposed to stabilize the training of GAN using proposed gradient-norm regularizer.
This regularization is designed for conventional GAN, or more general f-GAN proposed last year.
The idea is interesting but the justification is a little bit coarse.
1. Eq. (15) is only correct for the maximizer \psi^{\star}. However, the regularizer defined in (21) is for arbitrary \psi, which contradicts this assumption.
2. It seems that increasing the weighting of the regularization term, i.e., \gamma does not affect much the training in Fig. 2.
The authors claim that 'the results clearly demonstrate the robustness of the regularizer w.r.t. the various regularization bandwidths'.
This is a little bit strange and it will be necessary to show how this regularization can affect the training.
3. For the comparison in the experiments, it is not clear how the explicit noise approach was done. What is the power of the noise? How is the batch-size-to-noise-ratios defined? What's relation between it and the conventional SNR?
4. The results in Section 4.3 make no much sense. From the reported table, the diagonal elements are all quite close to one, which can hardly justifies the advantage of regularized GAN.
5. It will be convincing to compare the proposed method with some other stabilizing training techniques, like Salimans et al 2016 or WGAN technique.