In general I find this to be a good paper and vote for acceptance.

The paper is well-written and easy to follow.

The proposed approach is a useful addition to existing literature.

Besides that I have not much to say except one point I would like to discuss:

In 4.2 I am not fully convinced of using an adversial model for goal generation.

RL algorithms generally suffer from poor stability

and GANs themselves can have convergence issues.

This imposes another layer of possible instability.

Besides, generating useful reward function, while not trivial, can be seen as easier than solving the full RL problem.

Can the authors argue why this model class was chosen over other, more simple, generative models?

Furthermore, did the authors do experiments with simpler models?

Related: "We found that the LSGAN works better than other forms of GAN for our problem."

Was this improvement minor, or major, or didn't even work with other GAN types?

This question is important,

because for me the big question is if this model is universal and stable in a lot of applications or requires careful fine-tuning and monitoring.

evaluation evaluation evaluation evaluation evaluation evaluation evaluation fact evaluation request request quote request evaluation evaluation


1) Summary This paper proposed a new method for predicting multiple future frames in videos.

A new formulation is proposed where the frames’ inherent noise is modeled separate from the uncertainty of the future.

This separation allows for directly modeling the stochasticity in the sequence through a random variable z ~ p(z)  where the posterior  q(z | past and future frames) is approximated by a neural network,

and as a result, sampling of a random future is possible through sampling from the prior p(z) during testing.

The random variable z can be modeled in a time-variant and time-invariant way.

Additionally, this paper proposes a training procedure to prevent their method from ignoring the stochastic phenomena modeled by z.

In the experimental section, the authors highlight the advantages of their method in 1) a synthetic dataset of shapes meant to clearly show the stochasticity in the prediction, 2) two robotic arm datasets for video prediction given and not given actions, and 3) A challenging human action dataset in which they perform future prediction only given previous frames.

2) Pros: + Novel/Sound future frame prediction formulation and training for modeling the stochasticity of future prediction.

+ Experiments on the synthetic shapes and robotic arm datasets highlight the proposed method’s power of multiple future frame prediction possible.

+ Good analysis on the number of samples improving the chance of outputting the correct future, the modeling power of the posterior for reconstructing the future, and a wide variety of qualitative examples.

+ Work is significant for the problem of modeling the stochastic nature of future frame prediction in videos.

3) Cons: Approximate posterior in non-synthetic datasets: The variable z seems to not be modeling the future very well.

In the robot arm qualitative experiments, the robot motion is well modeled, however, the background is not.

Given that for the approximate posterior computation the entire sequence is given (e.g. reconstruction is performed),

I would expect the background motion to also be modeled well.

This issue is more evident in the Human 3.6M experiments,

as it seems to output blurriness regardless of the true future being observed.

This problem may mean the method is failing to model a large variety of objects and clearly works for the robotic arm

because a very similar large shape (e.g. robot arm) is seen in the training data.

Do you have any comments on this?

Finn et al 2016 PNSR performance on Human 3.6M:

Is the same exact data, pre-processing, training, and architecture being utilized?

In her paper, the PSNR for the first timestep on Human 3.6M is about 41 (maybe 42?)  while in this paper it is 38.

Additional evaluation on Human 3.6M: PSNR is not a good evaluation metric for frame prediction

as it is biased towards blurriness,

and also SSIM does not give us an objective evaluation in the sense of semantic quality of predicted frames.

It would be good if the authors present additional quantitative evaluation to show that the predicted frames contain useful semantic information [1, 2, 3, 4].

For example, evaluating the predicted frames for the Human 3.6M dataset to see if the human is still detectable in the image or if the expected action is being predicted could be useful to verify that the predicted frames contain the expected meaningful information compared to the baselines.

Additional comments: Are all 15 actions being used for the Human 3.6M experiments?

If so, the fact of the time-invariant model performs better than the time-variant one may not be the consistent action being performed (last sentence of 5.2).

The motion performed by the actors in each action highly overlaps (talking on the phone action may go from sitting to walking a little to sitting again, and so on).

Unless actions such as walking and discussion were only used, it is unlikely the time-invariant z is performing better because of consistent action.

Do you have any comments on this?

4) Conclusion This paper proposes an interesting novel approach for predicting multiple futures in videos,

however, the results are not fully convincing in all datasets.

If the authors can provide additional quantitative evaluation besides PSNR and SSIM (e.g. evaluation on semantic quality), and also address the comments above, the current score will improve.

References: [1] Emily Denton and Vighnesh Birodkar. Unsupervised Learning of Disentangled Representations from Video. In NIPS, 2017.

[2] Ruben Villegas, Jimei Yang, Yuliang Zou, Sungryull Sohn, Xunyu Lin, and Honglak Lee. Learning to generate long-term future via hierarchical prediction. In ICML, 2017.

[3] Tero Karras, Timo Aila, Samuli Laine, and Jaakko Lehtinen. Progressive Growing of GANs for Improved Quality, Stability, and Variation. arXiv preprint arXiv:1710.10196, 2017.

[4] Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved Techniques for Training GANs. In NIPS, 2017.

fact fact fact fact fact fact fact fact evaluation evaluation evaluation evaluation evaluation fact evaluation evaluation evaluation evaluation fact non-arg reference request fact evaluation fact fact request request non-arg fact evaluation evaluation non-arg evaluation evaluation request reference reference reference reference


Summary ======== The authors present CLEVER, an algorithm which consists in evaluating the (local) Lipschitz constant of a trained network around a data point.

This is used to compute a lower-bound on the minimal perturbation of the data point needed to fool the network.

The method proposed in the paper already exists for classical function,

they only transpose it to neural networks.

Moreover, the lower bound comes from basic results in the analysis of Lipschitz continuous functions.

Clarity ===== The paper is clear and well-written.

Originality ========= This idea is not new:

if we search for "Lipschitz constant estimation" in google scholar, we get for example Wood, G. R., and B. P. Zhang. "Estimation of the Lipschitz constant of a function." (1996)

which presents a similar algorithm (i.e., estimation of the maximum slope with reverse Weibull).

Technical quality ============== The main theoretical result in the paper is the analysis of the lower-bound on \delta, the smallest perturbation to apply on a data point to fool the network.

This result is obtained almost directly by writing the bound on Lipschitz-continuous function | f(y)-f(x) | < L || y-x || where x = x_0 and y = x_0 + \delta.

Comments: - Lemma 3.1: why citing Paulavicius and Zilinskas for the definition of Lipschitz continuity?

Moreover, a Lipschitz-continuous function does not need to be differentiable at all (e.g. |x| is Lipschitz with constant 1 but sharp at x=0).

Indeed, this constant can be easier obtained if the gradient exists,

but this is not a requirement.

- (Flaw?) Theorem 3.2 : This theorem works for fixed target-class

since g = f_c - f_j for fixed g.

However, once g = min_j f_c - f_j, this theorem is not clear with the constant Lq.

Indeed, the function g should be  g(x) = min_{k \neq c} f_c(x) - f_k(x).

Thus its Lipschitz constant is different, potentially equal to L_q = max_{k} \| L_q^k \|, where L_q^k is the Lipschitz constant of f_c-f_k.

If the theorem remains unchanged after this modification, you should clarify the proof.

Otherwise, the theorem will work with the maximum over all Lipschitz constants but the theoretical result will be weakened.

- Theorem 4.1: I do not see the purpose of this result in this paper.

This should be better motivated.

Numerical experiments ==================== Globally, the numerical experiments are in favor of the presented method.

The authors should also add information about the time it takes to compute the bound, the evolution of the bound in function of the number of samples and the distribution of the relative gap between the lower-bound and the best adversarial example.

Moreover, the numerical experiments look to be realized in the context of targeted attack.

To show the real effectiveness of the approach, the authors should also show the effectiveness of the lower-bound in the context of non-targeted attack.

fact fact fact fact fact evaluation evaluation fact evaluation fact evaluation evaluation fact evaluation fact fact fact evaluation request fact request fact evaluation request evaluation request evaluation request


The paper presents a method to parametrize unitary matrices in an RNN as a Kronecker product of smaller matrices.

Given N inputs and output, this method allows one to specify a linear transformation with O(log(N)) parameters, and perform a forward and backward pass in O(Nlog(N)) time.

In addition a relaxation is performed allowing each constituent to deviate a bit from unitarity (“soft unitary constraint”).

The paper shows nice results on a number of small tasks.

The idea is original to the best of my knowledge and is presented clearly.

I especially like the idea of “soft unitary constraint” which can be applied very efficiently in this factorized setup.

I think this is the main contribution of this work.

However the paper in its current form has a number of problems:

- The authors state that a major shortcoming of previous (efficient) unitary RNN methods is the lack of ability to span the entire space of unitary matrices.

This method presents a family that can span the entire space, but the efficient parts of this family (which give the promised speedup) only span a tiny fraction of it,

as they require only O(log(N)) params to specify an O(N^2) unitary matrix.

Indeed in the experimental section only those members are tested.

- Another claim that is made is that complex numbers are key, and again the argument is the need to span the entire space of unitary matrices,

but the same comment still hold - that is not the space this work is really dealing with,

and no experimental evidence is provided that using complex numbers was really needed.

- In the experimental section an emphasis is made as to how small the number of recurrent params are,

but at the same time the input/output projections are very large, leaving the reader wondering if the workload simply shifted from the RNN to the projections.

This needs to be addressed.

- Another aspect of the previous points is that it’s not clear if stacking KRU layers will work well.

This is important

as stacking LSTMs is a common practice.

Efficient KRU span a restricted subspace whose elements might not compose into structures that are expressive enough.

One way to overcome this potential problem is to add projection matrices between layers that will do some mixing,

but this will blow the number of parameters.

This needs to be explored.

- The authors claim that the soft unitary constraint was key for the success of the network,

yet no details are provided as to how this constraint was applied,

and no analysis was made for its significance.

fact fact fact evaluation evaluation evaluation evaluation fact fact fact fact fact fact fact fact fact evaluation request evaluation evaluation evaluation fact fact fact request fact fact fact


This paper proposes for training a question answering model from answers only and a KB by learning latent trees that capture the syntax and learn the semantic of words, including referential terms like "red" and also compositional operators like "not".

I think this model is elegant, beautiful and timely.

The authors do a good job of explaining it clearly.

I like the modules of composition that seem to make a very intuitive sense for the "algebra" that is required and the parsing algorithm is clean.

However, I think that the evaluation is lacking, and in some sense the model exposes the weakness of the dataset that it uses for evaluation.

I have 2.5 major issues with the paper and a few minor comments:

Parsing: * The authors don't really say what is the base case for \Psi that scores tokens

(unless I missed it and if indeed it is missing it really needs to be added)

and only provide the recursive case.

From that I understand that the only features that they use are whether a certain word makes sense in a certain position of the rule application in the context of the question.

While these features are based on Durrett et al.'s neural syntactic parser it seems like a pretty weak signal to learn from.

This makes me wonder, how does the parser learn whether one parse is better than the other?

Only based on this signal?

It makes me suspicious that the distribution of language is not very ambiguous and that as long as you can construct a tree in some context you can do it in almost any other context.

This is probably due to the fact that the CLEVR dataset was generated mostly using templates and is not really natural utterances produced by people.

Of course many people have published on CLEVR although of its language limitations,

but I was a bit surprised that only these features are enough to solve the problem completely,

and this makes me curious as to how hard is it to reverse-engineer the way that the language was generated with a context-free mechanism that is similar to how the data was produced.

* Related to that is that the decision for a score of a certain type t for a span (i,j) is the sum for all possible rule applications, rather than a max, which again means that there is no competition between different parse trees that result with the same type of a single span.

Can the authors say something about what the parser learns?

Does it learn to extract from the noise clear parse trees?

What is the distribution of rules in those sums?

is there some rule that is more preferred than others usually?

It seems like there is loss of information in the sum

and it is unclear what is the effect of that in the paper.

Evaluation: * Related to that is indeed the fact that they use CLEVR only.

There is now the Cornell NLVR dataset that is more challenging from a language perspective

and it would be great to have an evaluation there as well.

Also the authors only compare to 3 baselines where 2 don't even see the entire KB,

so the only "real" baseline is relation net.

The authors indeed state that it is state-of-the-art on clevr.

* It is worth noting that relation net is reported to get 95.5 accuracy while the authors have 89.4.

They use a subset so this might be the reason,

but I am not sure how they compared to relation net exactly.

Did they re-tune parameters once you have the new dataset?

This could make a difference in the final accuracy and cause an unfair advantage.

* I would really appreciate more analysis on the trees that one gets.

Are sub-trees interpretable?

Can one trace the process of composition?

This could have been really nice if one could do that.

The authors have a figure of a purported tree, but where does this tree come from?

From the mode?

Form the authors?

Scalability: * How much of a problem would it be to scale this?

Will this work in larger domains?

It seems they compute an attention score over every entity and also over a matrix that is squared in the number of entities.

So it seems if the number of entities is large that could be very problematic.

Once one moves to larger KBs it might become hard to maintain full differentiability which is one of the main selling points of the paper.

Minor comments: * I think the phrase "attention" is a bit confusing -

I thought of a distribution over entities at first.

* The feature function is not super clearly written I think - perhaps clarify in text a bit more what it does.

* I did not get how the denotation that is based on a specific rule applycation t_1 + t_2 --> t works.

Is it by looking at the grounding that is the result of that rule application?

* Authors say that the neural enquirer and neural symbolic machines produce flat programs -

that is not really true, the programs are just a linearized form of a tree,

so there is nothing very flat about it in my opinion.

Overall, I really enjoyed reading the paper,

but I was left wondering whether the fact that it works so well mostly attests to the way the data was generated and am still wondering how easy it would be to make this work in for more natural language or when the KB is large.

fact evaluation evaluation evaluation evaluation non-arg fact request fact fact evaluation non-arg non-arg evaluation evaluation fact evaluation evaluation fact request non-arg non-arg non-arg evaluation evaluation fact fact request fact evaluation fact fact fact non-arg non-arg fact request non-arg non-arg evaluation non-arg non-arg non-arg non-arg non-arg fact evaluation evaluation evaluation non-arg evaluation evaluation non-arg fact fact evaluation evaluation evaluation


The paper solves the problem of how to do autonomous resets,

which is an important problem in real world RL.

The method is novel,

the explanation is clear,

and has good experimental results.

Pros: 1. The approach is simple, solves a task of practical importance, and performs well in the experiments.

2. The experimental section performs good ablation studies wrt fewer reset thresholds, reset attempts, use of ensembles.

Cons: 1. The method is evaluated only for 3 tasks, which are all in simulation, and on no real world tasks.

Additional tasks could be useful, especially for qualitative analysis of the learned reset policies.

2. It seems that while the method does reduce hard resets,

it would be more convincing if it can solve tasks which a model without a reset policy couldnt.

Right now, the methods without the reset policy perform about equally well on final reward.

3. The method wont be applicable to RL environments where we will need to take multiple non-invertible actions to achieve the goal (an analogy would be multiple levels in a game).

In such situations, one might want to use the reset policy to go back to intermediate “start” states from where we can continue again, rather than the original start state always.

Conclusion/Significance: The approach is a step in the right direction,

and further refinements can make it a significant contribution to robotics work.

fact evaluation evaluation evaluation evaluation evaluation fact fact request fact evaluation fact fact evaluation evaluation evaluation


This paper investigates human priors for playing video games.

Considering a simple video game, where an agent receives a reward when she completes a game board, this paper starts by stating that: -	Firstly, the humans perform better than an RL agent to complete the game board.

-	Secondly, with a simple modification of textures the performances of human players collapse, while those of a RL agent stay the same.

If I have no doubts about these results, I have a concern about the method.

In the case of human players the time needed to complete the game is plotted,

and in the case of a RL agent the number of steps needed to complete the game is plotted (fig 1).

Formally, we cannot conclude that one minute is lesser than 4 million of steps.

This issue could be easily fixed.

Unfortunately, I have other concerns about the method and the conclusions.

For instance, masking where objects are or suppressing visual similarity between similar objects should also deteriorate the performance of a RL agent.

So it cannot be concluded that the change of performances is due to human priors.

In these cases, I think that the change of performances is due to the increased difficulty of the game.

The authors have to include RL agent in all their experiments to be able to dissociate what is due to human priors and what is due to the noise introduced in the game.

fact fact fact evaluation fact fact fact evaluation evaluation fact fact fact request


The paper suggests taking GloVe word vectors, adjust them, and then use a non-Euclidean similarity function between them.

The idea is tested on very small data sets (80 and 50 examples, respectively).

The proposed techniques are a combination of previously published steps,

and the new algorithm fails to reach state-of-the-art on the tiny data sets.

It isn't clear what the authors are trying to prove,

nor whether they have successfully proven what they are trying to prove.

Is the point that GloVe is a bad algorithm?

That these steps are general?

If the latter, then the experimental results are far weaker than what I would find convincing.

Why not try on multiple different word embeddings?

What happens if you start with random vectors?

What happens when you try a bigger data set or a more complex problem?

fact fact fact fact evaluation evaluation non-arg non-arg evaluation request non-arg non-arg


This paper presents a method to cope with adversarial examples in classification tasks, leveraging a generative model of the inputs.

Given an accurate generative model of the input, this approach first projects the input onto the manifold learned by the generative model

(the idea being that inputs on this manifold reflect the non-adversarial input distribution).

This projected input is then used to produce the classification probabilities.

The authors test their method on various adversarially constructed inputs (with varying degrees of noise).

Questions/Comments: - I am interested in unpacking the improvement of Defense-GAN over the MagNet auto-encoder based method.

Is the MagNet auto-encoder suffering lower accuracy because the projection of an adversarial image is based on an encoding function that is learned only on true data?

If the decoder from the MagNet approach were treated purely as a generative model, and the same optimization-based projection approach (proposed in this work) was followed, would the results be comparable?

- Is there anything special about the GAN approach, versus other generative approaches?

- In the black-box vs. white-box scenarios, can the attacker know the GAN parameters?

Is that what is meant by the "defense network" (in experiments bullet 2)?

- How computationally expensive is this approach take compared to MagNet or other adversarial approaches?

Quality: The method appears to be technically correct.

Clarity: This paper clearly written;

both method and experiments are presented well.

Originality: I am not familiar enough with adversarial learning to assess the novelty of this approach.

Significance: I believe the main contribution of this method is the optimization-based approach to project onto a generative model's manifold.

I think this kernel has the potential to be explored further (e.g. computational speed-up, projection metrics).

fact fact fact fact fact evaluation non-arg non-arg non-arg non-arg non-arg non-arg evaluation evaluation evaluation non-arg evaluation evaluation


The article "Do GANs Learn the Distribution? Some Theory and Empirics" considers the important problem of quantifying whether the distributions obtained from generative adversarial networks come close to the actual distribution of images.

The authors argue that GANs in fact generate the distributions with fairly low support.

The proposed approach relies on so-called birthday paradox

which allows to estimate the number of objects in the support by counting number of matching (or very similar) pairs in the generated sample.

This test is expected to experimentally support the previous theoretical analysis by Arora et al. (2017).

The further theoretical analysis is also performed showing that for encoder-decoder GAN architectures the distributions with low support can be very close to the optimum of the specific (BiGAN) objective.

The experimental part of the paper considers the CelebA and CIFAR-10 datasets.

We definitely see many very similar images in fairly small sample generated.

So, the general claim is supported.

However, if you look closely at some pictures, you can see that they are very different though reported as similar.

For example, some deer or truck pictures.

That's why I would recommend to reevaluate the results visually,

which may lead to some change in the number of near duplicates and consequently the final support estimates.

To sum up, I think that the general idea looks very natural and the results are supportive.

On theoretical side, the results seem fair (though I didn't check the proofs)

and, being partly based on the previous results of Arora et al. (2017), clearly make a step further.

fact fact fact fact fact fact fact evaluation evaluation fact fact request evaluation evaluation evaluation evaluation


The proposed method is a classifier that is fair and works in collaboration with an unfair (but presumably accurate model).

The novel classifier is the result of the optimisation of a loss function

(composed of a part similar to a logistic regression model and a part being the disparate impact).

Hence, it can be interpreted as a logistic loss with a fairness regularisation.

The results are promising and the applications are very important for the acceptance of ML approaches in the society.

However, I believe that the model could be made more general (than a fairness regularized logistic loss) and its theoretical properties studied.

Finally, this paper used uncommon vocabulary (for the machine learning community)

and it make is difficult to follow sometimes (for example, the use of a Decision-Maker entity).

When reading the submitted paper, it was unclear (until section 6) how deferring could help fairness.

Hence, the structure of the paper could maybe be improved by introducing the cost function earlier in the manuscript (as a fairness regularised loss).

To conclude, although the application is of high interest and the numerical results encouraging,

the methodological approach does not seem to be very novel.

Minor comment : - The list of authors of the reference “Machine bias : theres software…” apperars incorrectly (some comma may be missing in the .bib file)

and there is a small typo in the title.

Possible extensions :- The proposed fairness aware loss could be made more general (and not only in the case of a logistic model)

- It could also be generalised to a mixture of biased classifier (more than on DM).

evaluation fact fact fact evaluation evaluation evaluation evaluation evaluation request evaluation evaluation fact fact request request


This paper proposes to use RGANs and RCGANS to generate synthetic sequences of actual data.

They demonstrate the quality of the sequences on sine waves, MNIST, and ICU telemetry data.

The authors demonstrate novel approaches for generating real-valued sequences using adversarial training, a train on synthetic, test of real and vice versa method for evaluating GANS, generating synthetic medical time series data, and an empirical privacy analysis.

Major - the medical use case is not motivating.

de-identifying the 4 telemetry measures is extremely easy

and there is little evidence to show that it is even possible to reidentify individuals using these 4 measures.

our institutional review board would certainly allow self-certification of the data (i.e. removing the patient identifiers and publishing the first 4 hours of sequences).

- the labels selected by the authors for the icu example are to forecast the next 15 minutes and whether a critical value is reached.

Please add information about how this critical value was generated.

Also it would be very useful to say that a physician was consulted and that the critical values were "clinically" useful.

- the changes in performance of TSTR are large enough that I would have difficulty trusting any experiments using the synthetic data.

If I optimized a method using this synthetic data, I would still need to assess the result on real data.

- In addition it is unclear whether this synthetic process would actually generate results that are clinically useful.

The authors certainly make a convincing statement about the internal validity of the method.

An externally valid measure would strengthen the results.

I'm not quite sure how the authors could externally validate the synthetic data

as this would also require generating synthetic outcome measures.

I think it would be possible for the synthetic sequence to also generate an outcome measure (i.e. death) based on the first 4 hours of stay.

Minor- write in the description for table 1 what task the accuracies correspond.

Summary The authors present methods for generating synthetic sequences.

The MNIST example is compelling.

However the ICU example has some pitfalls which need to be addressed.

fact fact fact evaluation evaluation evaluation non-arg fact request request evaluation evaluation evaluation evaluation evaluation evaluation fact fact request fact evaluation evaluation


The authors describe a new defense mechanism against adversarial attacks on classifiers (e.g., FGSM).

They propose utilizing Generative Adversarial Networks (GAN),

which are usually used for training generative models for an unknown distribution,

but have a natural adversarial interpretation.

In particular, a GAN consists of a generator NN G which maps a random vector z to an example x, and a discriminator NN D which seeks to discriminate between an examples produced by G and examples drawn from the true distribution.

The GAN is trained to minimize the max min loss of D on this discrimination task, thereby producing a G (in the limit) whose outputs are indistinguishable from the true distribution by the best discriminator.

Utilizing a trained GAN, the authors propose the following defense at inference time.

Given a sample x (which has been adversarially perturbed), first project x onto the range of G by solving the minimization problem z* = argmin_z ||G(z) - x||_2.

This is done by SGD.

Then apply any classifier trained on the true distribution on the resulting x* = G(z*).

In the case of existing black-box attacks, the authors argue (convincingly) that the method is both flexible and empirically effective.

In particular, the defense can be applied in conjunction with any classifier (including already hardened classifiers), and does not assume any specific attack model.

Nevertheless, it appears to be effective against FGSM attacks, and competitive with adversarial training specifically to defend against FGSM.

The authors provide less-convincing evidence that the defense is effective against white-box attacks.

In particular, the method is shown to be robust against FGSM, RAND+FGSM, and CW white-box attacks.

However, it is not clear to me that the method is invulnerable to novel white-box attacks.

In particular, it seems that the attacker can design an x which projects onto some desired x* (using some other method entirely), which then fools the classifier downstream.

Nevertheless, the method is shown to be an effective tool for hardening any classifier against existing black-box attacks

(which is arguably of great practical value).

It is novel and should generate further research with respect to understanding its vulnerabilities more completely.

Minor Comments: The sentence starting “Unless otherwise specified…” at the top of page 7 is confusing given the actual contents of Tables 1 and 2, which are clarified only by looking at Table 5 in the appendix.

This should be fixed.

fact fact fact evaluation fact fact fact fact fact fact fact fact fact evaluation fact evaluation fact fact evaluation evaluation evaluation request


This paper describes computationally efficient methods for training adversarially robust deep neural networks for image classification.

(These methods may extend to other machine learning models and domains as well, but that's beyond the scope of this paper.)

The former standard method for generating adversarially images quickly and using them in training was to do a single gradient step to increase the loss of the true label or decrease the loss of an alternate label.

This paper shows that such training methods only lead to robustness against these "weak" adversarial examples, leaving the adversarially-trained models vulnerable to multi-step white-box attacks and black-box attacks (adversarial examples generated to attack alternate models).

There are two proposed solutions.

The first is to generate additional adversarial examples from other models and use them in training.

This seems to yield robustness against black-box attacks from held-out models as well.

Of course, it requires that you have a somewhat diverse group of models to choose from.

If that's the case, why not directly build an ensemble of all the models?

An ensemble of neural networks can still be represented as a neural network, although a more computationally costly one.

Thus, while this heuristic appears to be useful with current models against current attacks,

I don't know how well it will hold up in the future.

The second solution is to add random noise before taking the gradient step.

This yields more effective adversarial examples, both for attacking models and for training,

because it relies less on the local gradient.

This is another simple idea that appears to be effective.

However, I would be interested to see a comparison to a 2-step gradient-based attack.

R+Step-LL can be viewed as a 2-step attack: a random step followed by a gradient step.

What if both steps were gradient steps instead?

This interpolates between Step-LL and I-Step-LL, with an intermediate computational cost.

It would be very interesting to know if R+Step-LL is more or less effective than 2+Step-LL, and how large the difference is.

I like that this paper demonstrates the weakness of previous methods, including extensive experiments and a very nice visualization of the loss landscape in two adversarial dimensions.

The proposed heuristics seem effective in practice,

but they're somewhat ad hoc

and there is no analysis of how these heuristics might or might not be vulnerable to future attacks.

fact fact evaluation fact fact fact evaluation fact request fact evaluation evaluation fact fact fact evaluation request evaluation non-arg fact evaluation fact evaluation evaluation fact


Authors describe a procedure of building their production recommender system from scratch, begining with formulating the recommendation problem, label data formation, model construction and learning.

They use several different evaluation techniques to show how successful their model is (offline metrics, A/B test results, etc.)

Most of the originality comes from integrating time decay of purchases into the learning framework.

Rest of presented work is more or less standard.

Paper may be useful to practitioners who are looking to implement something like this in production.

fact fact evaluation evaluation evaluation


The paper proposes a novel approach on estimating the parameters  \nof Mean field games (MFG).

The key of the method is a reduction of the unknown parameter MFG to an  unknown parameter Markov Decision Process (MDP).\n\n

This is an important class of models

and I recommend the acceptance of the paper.\n\n

I think that the general discussion about the collective behavior application should be more carefully presented

and some better examples of applications should be easy to provide.

In addition the authors may want to enrich their literature review

and give references to alternative work on unknown MDP estimation methods cf. [1], [2] below. \n\n

[1] Burnetas, A. N., & Katehakis, M. N. (1997). Optimal adaptive policies for Markov decision processes. Mathematics of Operations Research, 22(1), 222-255.\n\n

[2] Budhiraja, A., Liu, X., & Shwartz, A. (2012). Action time sharing policies for ergodic control of Markov chains. SIAM Journal on Control and Optimization, 50(1), 171-195.

fact fact evaluation evaluation request request request request reference reference


This paper proposes to use 3D conditional GAN models to generate fMRI scans.

Using the generated images, paper reports improvement in classification accuracy on various tasks.

One claim of the paper is that a generative model of fMRI data can help to caracterize and understand variability of scans across subjects.

Article is based on recent works such as Wasserstein GANs and AC-GANs by (Odena et al., 2016).

Despite the rich literature of this recent topic

the related work section is rather convincing.

Model presented extends IW-GAN by using 3D convolution and also by supervising the generator using sample labels.

Major: - The size of the generated images is up to 26x31x22

which is limited (about half the size of the actual resolution of fMRI data).

As a consequence results on decoding learning task using low resolution images can end up worse than with the actual data (as pointed out).

What it means is that the actual impact of the work is probably limited.

- Generating high resolution images with GANs even on faces for which there is almost infinite data is still a challenge.

Here a few thousand data points are used.

So it raises too concerns: First is it enough?

Using so-called learning curves is a good way to answer this.

Second is what are the contributions to the state-of-the-art of the 2 methods introduced?

Said differently, as there is no classification results using images produced by an another GAN architecture

it is hard to say that the extra complexity proposed here (which is a bit contribution of the work) is actually necessary.

Minor: - Fonts in figure 4 are too small.

fact fact fact fact evaluation evaluation fact fact evaluation fact evaluation evaluation fact evaluation evaluation evaluation fact evaluation request


The authors build on the work of Tang et al. (2017),

who made a minor change to the skip-thought model by decoding only the next sentence, rather than the previous one also.

The additional minor change in this paper is to use a CNN, rather than RNN, decoder.

I am sympathetic to the goals of the work, and believe this sort of work should be carried out,

but I see the contribution as too minor to constitute a paper at the conference track of a leading international conference such as ICLR.

Given the incremental nature of the work, I think this would be a good fit for something like a short paper at *ACL.

I found the more theoretical motivation of the CNN decoder not terribly convincing, and somewhat post-hoc.

I feel as though analogous arguments could just as easily be made for an RNN decoder.

Ultimately I see these questions - such as CNN vs. RNN for the decoder - as empirical ones.

Finally, the authors have admirably attempted a thorough comparison with existing work, in the related work section,

but this section takes up a large chunk of the paper at the end,

and again I would have preferred this section to be much shorter and more concise.

Summary: worthwhile empirical goal,

but the paper could have been easily written using half as much space.

evaluation fact evaluation evaluation evaluation evaluation evaluation evaluation evaluation evaluation fact request evaluation evaluation


This paper presents a reparametrization of the perturbation applied to features in adversarial examples based attacks.

It tests this attack variation on against Inception-family classifiers on ImageNet.

It shows some experimental robustness to JPEG encoding defense.

Specifically about the method: Instead of perturbating a feature x_i by delta_i, as in other attacks, with delta_i in range [-Delta_i, Delta_i], they propose to perturbate x_i^*, which is recentered in the domain of x_i through a heuristic ((x_i ± Delta_i + domain boundary that would be clipped)/2), and have a similar heuristic for computing a Delta_i^*.

Instead of perturbating x_i^* directly by delta_i, they compute the perturbed x by x_i^* + Delta_i^* * g(r_i),

so they follow the gradient of loss to misclassify w.r.t. r (instead of delta).

+/-: + The presentation of the method is clear.

+ ImageNet is a good dataset to benchmark on.

- (!) The (ensemble) white-box attack is effective

but the results are not compared to anything else, e.g. it could be compared to (vanilla) FGSM nor C&W.

- The other attack demonstrated is actually a grey-box attack,

as 4 out of the 5 classifiers are known, they are attacking the 5th,

but in particular all the 5 classifiers are Inception-family models.

- The experimental section is a bit sloppy at times (e.g. enumerating more than what is actually done, starting at 3.1.1.).

- The results on their JPEG approximation scheme seem too explorative (early in their development) to be properly compared.

I think that the paper need some more work, in particular to make more convincing experiments that the benefit lies in CIA (baselines comparison), and that it really is robust across these defenses shown in the paper.

fact fact fact fact fact fact evaluation evaluation evaluation fact fact fact fact evaluation evaluation request


Summary: The paper proposes to learn new priors for latent codes z  for GAN training.

for this the paper shows that there is a mismatch between the gaussian prior and an estimated of the latent codes of real data by reversal of the generator .

To fix this the paper proposes to learn a second GAN to learn the prior distributions of "real latent code" of the first GAN.

The first GAN then uses the second GAN as prior to generate the z codes.

Quality/clarity: The paper is well written and easy to follow.

Originality:pros: -The paper while simple sheds some light on important problem with the prior distribution used in GAN.

- the second GAN solution trained on reverse codes from real data is interesting

- In general the topic is interesting, the solution presented is simple but needs more study

cons: - It related to adversarial learned inference and BiGAN, in term of learning the mapping  z ->x, x->z and seeking the agreement.

- The solution presented is not end to end

(learning a prior generator on learned models have been done in many previous works on encoder/decoder)

General Review: More experimentation with the latent codes will be interesting:

- Have you looked at the decay of the singular values of the latent codes obtained from reversing the generator?

Is this data low rank?

how does this change depending on the dimensionality of the latent codes?

Maybe adding plots to the paper can help.

- the prior agreement score is interesting

but assuming gaussian prior also for the learned latent codes from real data is maybe not adequate.

Maybe computing the entropy of the codes using a nearest neighbor estimate of the entropy  can help understanding the entropy difference wrt to the isotropic gaussian prior?

- Have you tried to multiply the isotropic normal noise with the learned singular values and generate images from  this new prior  and compute inceptions scores etc?

Maybe also rotating the codes with the singular vector matrix V or \Sigma^{0.5} V?

- What architecture did you use for the prior generator GAN?

- Have you thought of an end to end way to learn the prior generator GAN?

fact fact fact fact evaluation evaluation evaluation evaluation fact fact fact request request request request request evaluation evaluation request request request request request


Paper studies an interesting phenomenon of overparameterised models being able to learn well-generalising solutions.

It focuses on a setting with three crucial simplifications:

- data is linearly separable

- model is 1-hidden layer feed forward network with homogenous activations

- **only input-hidden layer weights** are trained, while the hidden-output layer's weights are fixed to be (v, v, v, ..., v, -v, -v, -v, ..., -v) (in particular -- (1,1,...,1,-1,-1,...,-1))

While the last assumption does not limit the expressiveness of the model in any way,

as homogenous activations have the property of f(ax)=af(x) (for positive a)

and so for any unconstrained model in the second layer, we can "propagate" its weights back into first layer and obtain functionally equivalent network.

However, learning dynamics of a model of form  z(x) = SUM( g(Wx+b) ) - SUM( g(Vx+c) ) + d and "standard" neural model  z(x) = Vg(Wx+b)+c can be completely different.

Consequently, while the results are very interesting, claiming their applicability to the deep models is (at this point) far fetched.

In particular, abstract suggests no simplifications are being made, which does not correspond to actual result in the paper.

The results themselves are interesting,

but due to the above restriction it is not clear whether it sheds any light on neural nets, or simply described a behaviour of very specific, non-standard shallow model.

I am happy to revisit my current rating given authors rephrase the paper so that the simplifications being made are clear both in abstract and in the text, and that (at least empirically) it does not affect learning in practice.

In other words - all the experiments in the paper follow the assumption made, if authors claim is that the restriction introduced does not matter,but make proofs too technical - at least experimental section should show this.

If the claims do not hold empirically without the assumptions made, then the assumptions are not realistic and cannot be used for explaining the behaviour of models we are interested in.

Pros: - tackling a hard problem of overparametrised models, without introducing common unrealistic assumptions of activations independence

- very nice result of "phase change" dependend on the size of hidden layer in section 7

Cons: - simplification with non-trainable second layer is currently not well studied in the paper;

and while not affecting expressive power - it is something that can change learning dynamics completely

fact fact fact fact fact fact fact fact evaluation evaluation fact evaluation evaluation evaluation request evaluation evaluation evaluation evaluation evaluation


The author unveils some properties of the resnets, for example, the cosine loss and l2 ratio of the layers.

I think the author should place more focus to study "real" iterative inference with shared parameters rather than analyzing original resnets.

In resnet without sharing parameters, it is quite ambiguous to say whether it is doing representation learning or iterative refinement.

1. The cosine loss is not meaningful in the sense that the classification layer is trained on the output of the last residual block and fixed.

Moving the classification layer to early layers will definitely result in accuracy loss.

Even in non-residual network, we can always say that the vector h_{i+1} - h_i is refining h_i towards the negative gradient direction.

The motivation of iterative inference would be to generate a feature that is easier to classify rather than to match the current fixed classifier.

Thus the final classification layer should be retrained for every addition or removal of residual blocks.

2. The l2 ratio. The l2 ratio is small for higher residual layers, I'm not sure how much this phenomenon can prove that resnet is actually doing iterative inference.

3. In section 4.4 it is shown that unrolling the layers can improve the performance of the network.

However, the same can be achieved by adding more unshared layers.

I think the study should focus more on whether shared or unshared is better.

4. Section 4.5 is a bit weak in experiments,

my conclusion is that currently it is still limited by batch normalization and optimization,

the evidence is still not strong enough to show that iterative inference is advantageous / disadvantageous.

The the above said, I think the more important thing is how we can benefit from iterative inference interpretation, which is relatively weak in this paper.

fact request evaluation evaluation evaluation fact evaluation request evaluation fact evaluation request evaluation evaluation evaluation evaluation


This paper draws an interesting connection between deep neural networks and theories of quantum entanglement.

They leveraged the tool for analyzing quantum entanglement to deep neural networks,

and proposed a graph theoretical analysis for neural networks.

They demonstrated how their theory can help designing neural network architectures on the MNIST dataset.

I think the theoretical findings are novel

and may contribute to the important problem on understanding neural networks theoretically.

I am not familiar with the theory for quantum entanglement though.

evaluation fact fact fact evaluation evaluation fact


Pros: 1. It provided theoretic analysis why larger feature norm is preferred in feature representation learning.

2. A new regularization method (feature incay) is proposed.

Cons: It seems there is not much comparison between this proposed method and the concurrent work

"COCO(Liu et al. (2017c))".


This paper describes a method for computing representations for out-of-vocabulary words, e.g. based on their spelling or dictionary definitions.

The main difference from previous approaches is that the model is that the embeddings are trained end-to-end for a specific task, rather than trying to produce generically useful embeddings.

The method leads to better performance than using no external resources, but not as high performance as using Glove embeddings.

The paper is clearly written, and has useful ablation experiments.

However, I have a couple of questions/concerns: - Most of the gains seem to come from using the spelling of the word.

As the authors note, this kind of character level modelling has been used in many previous works.

- I would be slightly surprised if no previous work has used external resources for training word representations using an end-task loss,

but I don’t know the area well enough to make specific suggestions

- I’m a little skeptical about how often this method would really be useful in practice.

It seems to assume that you don’t have much unlabelled text (or you’d use Glove),

but you probably need a large labelled dataset to learn how to read dictionary definitions well.

All the experiments use large tasks

- it would be helpful to have an experiment showing an improvement over character-level modelling on a smaller task.

- The results on SQUAD seem pretty weak - 52-64%, compared to the SOTA of 81.

It seems like the proposed method is quite generic,

so why not apply it to a stronger baseline?

fact fact fact evaluation evaluation fact evaluation evaluation evaluation fact evaluation evaluation request evaluation evaluation request


This very well written paper covers the span between W-GAN and VAE.

For a reviewer who is not an expert in the domain, it reads very well,

and would have been of tutorial quality if space had allowed for more detailed explanations.

The appendix are very useful, and tutorial paper material (especially A).

While I am not sure description would be enough to reproduce and no code is provided, every aspect of the architecture, if not described, if referred as similar to some previous work.

There are also some notation shortcuts (not explained) in the proof of theorems that can lead to initial confusion, but they turn out to be non-ambiguous.

One that could be improved is P(P_X, P_G) where one loses the fact that the second random variable is Y.

This work contains plenty of novel material, which is clearly compared to previous work:

- The main consequence of the use of Wasserstein distance is the surprisingly simple and useful Theorem 1.

I could not verify its novelty, but this seems to be a great contribution.

- Blending GAN and auto-encoders has been tried in the past,

but the authors claim better theoretical foundations that lead to solutions that do not rquire min-max

- The use of MMD in the context of GANs has also been tried.

The authors claim that their use in the latent space makes it more practival

The experiments are very convincing, both numerically and visually.

Source of confusion: in algorithm 1 and 2, \tilde{z} is "sampled" from Q_TH(Z|xi),

some one is lead to believe that this is the sampling process as in VAEs, while in reality Q_TH(Z|xi) is deterministic in the experiments.

fact evaluation evaluation evaluation evaluation evaluation request evaluation evaluation evaluation fact fact fact fact evaluation evaluation evaluation


This paper presents an alternative approach to constructing variational lower bounds on data log likelihood in deep, directed generative models with latent variables.

Specifically, the authors propose using approximate posteriors shared across groups of examples, rather than posteriors which treat examples independently.

The group-wise posteriors allow amortization of the information cost KL(group posterior || prior) across all examples in the group,

which the authors liken to the "KL annealing" tricks that are sometimes used to avoid posterior collapse when training models with strong decoders p(x|z) using current techniques for approximate variational inference in deep nets.

The presentation of the core idea is solid,

though it did take two read-throughs before the equations really clicked for me.

I think the paper could be improved by spending more time on a detailed description of the model for the Omniglot experiments (as illustrated in Figure 3).

E.g., explicitly describing how group-wise and per-example posteriors are composed in this model, using Equations and pseudo-code for the main training loop, would have saved me some time.

For readers less familiar with amortized variational inference in deep nets, the benefit would be larger.

I appreciate that the authors developed extensions of the core method to more complex group structures,

though I didn't find the related experiments particularly convincing.

Overall, I like this paper

and think the underlying group-wise posterior construction trick is worth exploring further.

Of course, the elephant in the room is how to determine the groups across which the posteriors can be shared and their information costs amortized.

fact fact fact fact evaluation non-arg request request evaluation evaluation evaluation evaluation evaluation evaluation


This paper extends an existing thread of neural computation research focused on learning resuable subprocedures (or options in RL-speak).

Instead of simply input and output examples, as in most of the work in neural computation, they follow in the vein of the Neural Programmer-Interpreter (Reed and de Freitas, 2016) and Li et. al., 2017,

where the supervision contains the full sequence of elementary actions in the domain for all samples, and some samples also contain the hierarchy of subprocedure calls.

The main focus of their work is learning from fewer fully annotated samples than prior work.

They introduce two new ideas in order to enable this:

1.  They limit the memory state of each level in the program heirarchy to simply a counter indicating the number of elementary actions/subprocedure calls taken so far (rather than a full RNN embedded hidden/cell state as in prior work).

They also limit the subprocedures such that they do not accept any arguments.

2.  By considering this very limited set of possible hidden states, they can compute the gradients using a dynamic program that seems to be more accurate than the approximate dynamic program used in Li et. al., 2017.

The main limitation of the work is this extremely limited memory state, and the lack of arguments.

Without arguments, everything that parameterizes the subprocedures must be in the visible world state.

In both of their domains, this is true,

but this places a significant limitation on the algorithms which can be modeled with this technique.

Furthermore, the limited memory state means that the only way a subprocedure can remember anything about the current observation is to call a different subprocedure.

Again, their two evalation tasks fit into this paradigm,

but this places very significant limitations on the set of applicable domains.

I would have like to see more discussion on how constraining these limitations would be in practice.

For example, it seems it would be impossible for this architecture to perform the Nanocraft task if the parameters of the task (width, height, etc.) were only provided in the first observation, rather than every observation.

None-the-less I think this work is an important step in our understanding of the learning dynamics for neural programs.

In particular, while the RNN hidden state memory used by the prior work enables the learning of more complicted programs *in theory*, this has not been shown in practice.

So, it's possible that all the prior work is doing is learning to approixmate a much simpler architecture of this form.

Specifically, I think this work can act as a great base-line by forcing future work to focus on domains which cannot be easily solved by a simpler architecture of this form.

This limitation will also force the community to think about which tasks require a more complicated form of memory, and which can be solved with a very simple memory of this form.

I also have the following additional concerns about the paper: 1.  I found the current explanation of the algorithm to be very difficult to understand.

It's extremely difficult to understand the core method without reading the appendix,

and even with the appendix I found the explanation of the level-by-level decomposition to be too terse.

2.  It's not clear how their gradient approximation compares to the technique used by Li et. al.

They obviously get better results on the addition and Nanocraft domains,

but I would have liked a more clear explanation and/or some experiments providing insights into what enables these improvements (or at least an admission by the authors that they don't really understand what enabled the performance improvements).

fact fact fact fact fact fact fact fact evaluation fact fact evaluation fact fact evaluation request fact evaluation evaluation evaluation evaluation evaluation evaluation evaluation evaluation evaluation fact request


This paper proposes a new model for the general task of inducing document representations (embeddings).

The approach uses a CNN architecture, distinguishing it from the majority of prior efforts on this problem, which have tended to use RNNs.

This affords obvious computational advantages, as training may be parallelized.

Overall, the model presented is relatively simple (a good thing, in my view) and it indeed seems fast.

I can thus see potential practical uses of this CNN based approach to document embedding in future work on language tasks.

The training strategy, which entails selecting documents and then indexes within them stochastically, is also neat.

Furthermore, the work is presented relatively clearly.

That said, my main concerns regarding this paper are that: (1) there's not much new here, and,

(2) the experimental setup may be flawed,

in that it would seem model hyperparams were tuned for the proposed approach but not for the baselines;

I elaborate on these concerns below.

Specific comments:---- It's hard to tease out exactly what's new here:

the various elements used are all well known.

But perhaps there is merit in putting the specific pieces together.

Essentially, the novelty is using a CNN rather than an RNN to induce document embeddings.

- In Section 4.1, the authors write that they report results for their after running "parameter sweeps ..." --

I presume that these were performed on a validation set,

but the authors should say so.

In any case, a very potential weakness here: were analagous parameter sweeps for this dataset performed for the baseline models?

It would seem not, as the authors write "the IMDB training data using the default hyper-parameters" for skip-thought.

Surely it is unfair comparison if one model has been tuned to a given dataset while others use only the default hyper-parameters?

- Many important questions were left unaddressed in the experiments.

For example, does one really need to use the gating mechanism borrowed from the Dauphin et al. paper?

What happens if not?

How big of an effect does the stochastic sampling of document indices have on the learned embeddings?

Does the specific underlying CNN architecture affect results, and how much?

None of these questions are explored.

- I was left a bit confused regarding how the v_{1:i-1} embedding is actually estimated;

I think the details here are insufficient in the current presentation.

The authors write that this is a "function of all words up to w_{i-1}".

This would seem to imply that at test time, prediction is not in fact parallelizable, no?

Yet this seems to be one of the main arguments the authors make in favor of the model (in contrast to RNN based methods).

In fact, I think the authors are proposing using the (aggregated) filter activation vectors (h^l(x)) in eq. 5,

but for some reason this is not made explicit.

Minor comments:- In Eq. 4, should the product be element-wise to realize the desired gating (as per the Dauhpin paper)?

This should be made explicit in the notation.

- On the bottom of page 3, the authors claim "Expanding the prediction to multiple words makes the problem more difficult since the only way to achieve that is by 'understanding' the preceding sequence."

This claim should either by made more precise or removed.

It is not clear exactly what is meant here, nor what evidence supports it.

- Commas are missing in a few.

For example on page 2, probably want a comma after "in parallel" (before "significantly"); also after "parallelize" above "Approach".

- Page 4: "In contrast, our model addresses only requires"

--> drop the "addresses".

fact fact fact evaluation evaluation evaluation evaluation fact fact fact non-arg evaluation fact evaluation fact fact fact request fact fact evaluation evaluation request request request request fact evaluation request fact fact fact fact fact request request fact request evaluation fact request quote request


Summary This article considers neural networks over time-series, defined as a succession of convolutions and fully-connected layers with Leaky ReLU activations.

The authors provide relatively general conditions for transformations described by such networks to admit a Lipschitz-continuous inverse.

They extend these results to the case where the first layer is a convolution with irregular sampling.

Finally, they show that the first convolutional filters can be chosen so as to represent a discrete wavelet transform, and provide some numerical experiments.

Main remarks While the introduction seemed promising,

and I enjoyed the writing style,

I was disappointed with this article.

(1) There are many mistakes in the mathematical statements.

First, in Theorem 1.1, I do not think that phi_L \circ ... \circ phi_1 \circ F is a non-linear frame,

because I do not see why it should be of the form of Definition 1.2 (what would be the functions psi_n?).

For the same reason, I also do not understand Theorem 1.2.

In Proof 1.4, the line of equalities after « Also with the Plancherel formula » is, in my opinion, not true,

because the L^2 norm of a product of functions is not the product of the L^2 norms of the functions.

It also seems to me that Theorem 1.3, from [Benedetto, 1992], is incorrect:

it is not the limit of t_n/n that must be larger than 2R, but the limit of N_n/n (with N_n the number of t_i's that belong to the interval [-n;n]),

and there must probably be a compatibility condition between (t_n)_n and R_1, not only between (t_n)_n and R.

In Proposition 1.6, I think that the equality should be a strict inequality.

Additionally, I do not say that Proof 2.1 is not true,

but the fact that the undersampling by a factor 2 does not prevent the operator from being a frame should be justified.

(2) The authors do not justify, in the introduction, why admitting a continuous inverse should be a crucial criterion of quality for the representation described by a neural network.

Additionally, the existence of this continous inverse relies on the fact that the non-linearity that is used is a Leaky ReLU,

which looks a bit like "cheating" to me,

because the Lipschitz constant of the inverse of a Leaky ReLU, although finite, is large,

so it seems to me that cascading several layers with Leaky ReLUs could encode a transformation with strictly positive, but still very poor frame bounds.

(3) I also do not understand why having "orthogonal outputs", as in Section 2, is really desirable;

I think that it should be better justified.

Also, there are probably other ways to achieve orthogonality than using wavelets in the first layer,

so the fact that wavelets achieve orthogonality does not really justify why using wavelets in the first layer is a good choice, compared to other filters.

(4) I had understood in the introduction that the authors would explain how to define a (good) deep representation for data of the form (x_n)_{n\in\N}, where each x_n would be the value of a time series at instant t_n, with the t_n non-uniformly spaced.

But all the representations considered in the article seem to be applicable to functions in L^2(\R) only (like in Theorem 1.4 and Theorem 2.2), and not to sequences (x_n)_{n\in\N}.

There is something that I did not get here.

Minor remarks - Fourth paragraph, third line: "this generalization frames"?

- Last paragraph before "Contributions & Organization": "that that".

- Paragraph about notations: it seems to me that what is defined as l^2(R) is denoted as l^2(Z) after the introduction.

- Last line of this paragraph: R^d_1 should be R^{d_1}, and R^d_2 R^{d_2}.

- I think "smooth" could be replaced by "continuous"

(smoothness implies a notion of differentiability).

- Paragraph before Proposition 1.1: \sqrt{s} is not defined, and "is supported" should be "are supported".

- Theorem 1.1: the f_k should be phi_k.

- Definition 1.4: "piece-linear" -> "piecewise linear"?

- Lemma 1.2 and Proof 1.4: there are indices missing to \tilde h and \tilde g.

- Proof 1.4: "and finally" -> "And finally".

- Proof 1.5: I do not understand the grammatical structure of the second sentence.

- Proposition 1.4: the definition of a RNN is the same as definition 1.2 (except for the frame bounds);

I do not see why such transformations should model RNNs.

- Paragraph before Proposition 1.5: "in,formation".

- Proposition 1.6: it should be said on which space the frame is injective.

- On page 8, "Lipschitz" is erroneously written (twice).

- Proposition 1.7: "ProjW,l"?

- Definition 2.1: in the "nested" property, I think that the inclusion should be the other way around.

- Before Theorem 2.1, the sentence "Such Riesz basis is proven" is unclear to me.

- Theorem 2.1: "filters convolution filters".

- I think the architecture described in Theorem 2.2 could be clarified;

I am not exactly sure where all the arrows start from.

- First line of Subsection 2.3: ". is always" -> "is always".

- First paragraph of Subsection 3.2: "the the".

- Paragraph 3.2: could the previous algorithms developed for this dataset be described in slightly more detail?

I also do not understand the meaning of "must solely leverage the temporal structure".

- I think that the section about numerical experiments could be slightly rewritten, so that the architecture used in each experiment is clearer.

In Paragraph 3.2 in particular, I did not get why the architecture presented in Figure 6 has far fewer parameters than the one in Figure 5;

it would help if the authors clearly precised how many parameters each layer contains.

- Conclusion: "we can to" -> "we can".

- Definition 4.1: p_v(s) -> p_v(t).

fact evaluation fact fact evaluation evaluation evaluation fact evaluation evaluation evaluation evaluation fact fact fact fact evaluation non-arg request fact fact evaluation fact evaluation evaluation request evaluation evaluation evaluation evaluation non-arg evaluation request evaluation request request evaluation request request request request request evaluation fact evaluation non-arg request fact non-arg request evaluation non-arg request evaluation request non-arg request evaluation request evaluation request request request


The paper studies the problem of DNN loss function design for reducing intra-class variance in the output feature space.

The key contribution is proposing an isotropic variant of the softmax loss that can balance the accuracy of classification and compactness of individual class.

The proposed loss has been compared extensively against a number of closely related approaches in methodology.

Numerical results on benchmark datasets show some improvement of the proposed loss over softmax loss and center loss (Wen et al., 2016), when applied to distance-based classifiers such as k-NN and k-means.

Pros: - The idea of isotropic normalization for enhancing compactness of class is well motivated

- The paper is mostly clearly organized and presented.

- Numerical study shows some promise of the proposed method.

Cons: -  The novelty of method is mostly incremental given the prior work of (Wen et al., 2016) which has provided a slightly different isotropic variant of softmax loss.

- The training procedure of the proposed method remains unclear in this paper.

fact fact fact fact evaluation evaluation evaluation evaluation evaluation


This paper presents Defense-GAN: a GAN that used at test time to map the input generate an image (G(z)) close (in MSE(G(z), x)) to the input image (x), by applying several steps of gradient descent of this MSE.

The GAN is a WGAN trained on the train set (only to keep the generator).

The goal of the whole approach is to be robust to adversarial examples, without having to change the (downstream task) classifier, only swapping in the G(z) for the x.

+ The paper is easy to follow.

+ It seems (but I am not an expert in adversarial examples) to cite the relevant litterature (that I know of) and compare to reasonably established attacks and defenses.

+ Simple/directly applicable approach that seems to work experimentally,

but - A missing baseline is to take the nearest neighbour of the (perturbed) x from the training set.

- Only MNIST-sized images, and MNIST-like (60k train set, 10 labels) datasets: MNIST and F-MNIST.

- Between 0.043sec and 0.825 sec to reconstruct an MNIST-sized image.

? MagNet results were very often worse than no defense in Table 4,

could you comment on that?

- In white-box attacks, it seems to me like L steps of gradient descent on MSE(G(z), x) should be directly extended to L steps of (at least) FGSM-based attacks, at least as a control.

fact fact fact evaluation fact fact fact fact fact fact non-arg request


SIGNIFICANCE AND ORIGINALITY: The authors propose to accelerate the learning of complex tasks by exploiting traces of experts.

Unlike the most common form of imitation learning or behavioral cloning, the authors formulate their solution in the case where the expert’s state trajectory is observable, but the expert’s actions are not.

This is an important and useful problem in robotics and other applications.

Within this specific setting the authors differentiate their approach from others by developing a solution that does NOT estimate an explicit dynamics model ( e.g.,  P( S’ | S, A ) ).

The benefits of not estimating an explicit action model are not really demonstrated in a clear way.

The author’s articulate a specific solution that provides heuristic guidance rewards that cause the learner to favor actions that achieve subgoals calculated from expert behavior and refactors the representation of the Q function so that it has a component that is a function of the subgoal extracted from the expert.

These subgoals are linear functions of the expert’s change in state (or change in state features).

The resultant policy is a function of the expert traces on which it depends.

The authors show they can retrain a new policy that does not require the expert traces.

As far as I am aware, this is a novel approach to the problem.

The authors claim that this factorization is important and useful

but the paper doesn’t really illustrate this well.

They demonstrate the usefulness of the algorithm against a DQN baseline on Doom game problems.

The algorithm learns faster than unassisted DQN as shown by learning curve plots.

They also evaluate the algorithms on the quality of the final policies for their approach, DQN, and  a supervised learning from demonstration approach ( LfD ) that requires expert actions.

The proposed approach does as well or better than competing approaches.

QUALITY Ablation studies show that the guidance rewards are important to achieving the improved performance of the proposed method which is important confirmation that the architecture is working in the intended way.

However, it would also be useful to do an ablation study of the “factorization” of action values.

Is this important to achieving better results as well or is the guidance reward enough?

This seems like a key claim to establish.

CLARITY The details of the memory based kernel density estimation and neural gradient training seemed complicated by the way that the process was implemented.

Is it possible to communicate the intuitions behind what is going on?

I was able to work out the intuitions behind the heuristic rewards, but I still don’t clearly get what the Q-value factorization is providing:

To keep my text readable, I assume we are working in feature space instead of state space and use different letters for learner and expert:

Learner: S = \phi(s) Expert’s i^th state visit:  Ei = \phi( \hat{s}_i }  where Ei’ is the successor state to Ei

The paper builds upon approximate n-step discrete-action Q-learning where the Q value for an action is a linear function of the state features: Qp(S,a) = Wa S + Ba where parameters p = ( Wa, Ba ).

After observing an experience ( S,A,R,S’ ) we use Bellman Error as a loss function to optimize Qp for parameter p.

I ignore the complexities of n-step learning and discount factors for clarity.

Loss = E[    R + MAXa’ Qp(S’,a’)    -   Qp(S,a)   ]

The authors suggest we can augment the environment reward R with a heuristic reward Rh proportional to the similarity between the learner “subgoal" and the expert “subgoal" in similar states.

The authors propose to use cosine distance between representations of what they call the “subgoals” of learner and expert.

A subgoal is defined as a linear transformation of the distance traveled by an agent during a transition.

The heuristic reward is proportional to the cosine distance between the learner and expert “subgoals" Rh = B  <   Wv LearnerDirectionInStateS,  Wv ExpectedExpertDirectionInStatesSimilarToS   > The learner’s direction in state S is just (S-S’) in feature space.

The authors model the behavior of the expert as a kernel density type approximator giving the expected direction of the expert starting from a states similar to the one the learner is in.

Let < Wk S, Wk Ej > be a weighted similarity between learner state features S and expert state features Ej and Ej’ be the successor state features encountered by the expert.

Then the expected expert direction for learner state S is: SUMj  < Wk S, Wk Ej > ( Ej - Ej’ )

Presumably the linear Wk transform helps us pick out the important dimensions of similarity between S and Ej.

Mapping the learner and expert directions into subgoal space using Wv, the heuristic reward is Rh = B <   Wv (S-S’),  Wv SUMj  < Wk S, Wk Ej > ( Ej - Ej’ ) >

I ignore the ReLU here, but I assume that is operates element-wise and just clips negative values?

There is only one layer here

so we don’t have complex non-linear things going on?

In addition to introducing a heuristic reward term, the authors propose to alter the Q-function to be specific to the subgoal.

Q( s,a,g ) = g(S) Wa S + Ba

The subgoal is the same as the first part, namely a linear transform of the expected expert direction in states similar to state S.

g(S) =  Wv   SUMj  < Wk S, Wk Ej >  ( Ej - Ej’ )

So in some sense, the Q function is really just a function of S, as g is calculated from S.

Q( S,a ) = g(S) Wa S + Ba

So this allows the Q-function more flexibility to capture each subgoal in a different linear space?

I don’t really get the intuition behind this formulation.

It allows the subgoal to adjust the value of the underlying model?

Essentially the expert defines a new Q-value problem at every state for the learner?

In some sense are we are defining a model for the action taken by the expert?

ADDITIONAL THOUGHTS While the authors compare to an unassisted baseline, they don’t compare to methods that use an action model

which is not a fatal flaw but would have been nice.

One can imagine there might be scenarios where the local guidance rewards of this form could be problematic, particularly in scenarios where the expert and learner are not identical

and it is possible to return to previous states, such as the grid worlds the authors discuss:

If the expert’s first few transitions were easily approximable, the learner would get local rewards that cause it to mimic expert behavior.

However, if the next step in the expert’s path was difficult to approximate, then the reward for imitating the expert would be lower.

Would the learner then just prefer to go back towards those states that it can approximate and endlessly loop?

In this case, perhaps expressing heuristic rewards as potentials as described in Ng’s shaping paper might solve the problem.

PROS AND CONS Important problem generally.

Avoiding the estimation of a dynamics model was stated as a given, but perhaps more could be put into motivating this goal.

Hopefully it is possible to streamline the methodology section to communicate the intuitions more easily.

fact fact evaluation fact evaluation fact fact fact fact evaluation fact evaluation fact fact fact fact evaluation request request evaluation evaluation request evaluation non-arg non-arg evaluation fact non-arg fact fact fact fact fact fact fact fact fact fact fact fact evaluation fact fact fact fact fact fact request evaluation request fact request fact evaluation evaluation fact evaluation fact request request evaluation request request


This paper attacks an important problems with an interesting and promising methodology.

The authors deal with inference in models of collective behavior, specifically at how to infer the parameters of a mean field game representation of collective behavior.

The technique the authors innovate is to specify a mean field game as a model, and then use inverse reinforcement learning to learn the reward functions of agents in the mean field game.

This work has many virtues, and could be an impactful piece.

There is still minimal work at the intersection of machine learning and collective behavior,

and this paper could help to stimulate the growth of that intersection.

The application to collective behavior could be an interesting novel application to many in machine learning,

and conversely the inference techniques that are innovated should be novel to many researchers in collective behavior.

At the same time, the scientific content of the work has critical conceptual flaws.

Most fundamentally, the authors appear to implicitly center their work around highly controversial claims about the ontological status of group optimization, without the careful justification necessary to make this kind of argument.

In addition to that, the authors appear to implicitly assume that utility function inference can be used for causal inference.

That is, there are two distinct mistakes the authors make in their scientific claims:

1) The authors write as if mean field games represent population optimization

(Mean field games are not about what a _group_ optimizes; they are about what _individuals_ optimize, and this individual optimization leads to certain patterns in collective behaviors)

2) The authors write as if utility/reward function inference alone can provide causal understanding of collective or individual behavior

1 - I should say that I am highly sympathetic to the claim that many types of collective behavior can be viewed as optimizing some kind of objective function.

However, this claim is far from mainstream, and is in fact highly contested.

For instance, many prominent pieces of work in the study of collective behavior have highlighted its irrational aspects, from the madness of crowds to herding in financial markets.

Since it is so fringe to attribute causal agency to groups, let alone optimal agency,

in the remainder of my review I will give the authors the benefit of the doubt and assume when they say things like "population behavior may be optimal", they mean "the behavior of individuals within a population may be optimal".

If the authors do mean to say this, they should be more careful about their language use in this regard (individuals are the actors, not populations).

If the authors do indeed mean to attribute causal agency to groups (as suggested in their MDP representation), they will run into all the criticisms I would have about an individual-level analysis and more.

Suffice it to say, mean field games themselves don't make claims about aggregate-level optimization.

A Nash equilibrium achieves a balance between individual-level reward functions.

These reward functions are only interpretable at the individual level.

There is no objective function the group itself in aggregate is optimizing in mean field games.

For instance, even though the mean field game model of the Mexican wave produces wave solutions,

the model is premised on people having individual utility functions that lead to emergent wave behavior.

The model does not have the representational capacity to explain that people actually intend to create the emergent behavior of a wave (even though in this case they do).

Furthermore, the fact that mean field games aggregate to a single-agent MDP does not imply that that the group can rightfully be thought of as an agent optimizing the reward function,

because there is an exact correspondence between the rewards of the individual agents in the MFG and of the aggregate agent in the MDP by construction.

2 - The authors also claim that their inference methods can help explain why people choose to talk about certain topics.

As far as the extent to which utility / reward function inference can provide causal explanations of individual (or collective) behavior, the argument that is invariably brought against a claim of optimization is that almost any behavior can be explained as optimal post-hoc with enough degrees of freedom in the utiliy function of the behavioral model.

Since optimization frameworks are so flexible,

they have little explanatory power and are hard to falsify.

In fact, there is literally no way that the modeling framework of the authors even affords the possibility that individual/collective behavior is not optimal.

Optimality is taken as an assumption that allows the authors to infer what reward function is being optimized.

The authors state that the reward function they infer helps to interpret collective behavior

because it reveals what people are optimizing.

However, the reward function actually discovered is not interpretable at all.

It is simply a summary of the statistical properties of changes in popularity of the topics of conversation in the Twitter data the authors' study.

To quote the authors' insights: "The learned reward function reveals that a real social media population favors states characterized by a highly non-uniform distribution with negative mass gradient in decreasing order of topic popularity, as well as transitions that increase this distribution imbalance."

The authors might as well have simply visualized the topic popularities and changes in popularities to arrive at such an insight.

To take the authors claims literally, we would say that people have an intrinsic preference for everyone to arbitrarily be talking about the same thing, regardless of the content or relevance of that topic.

To draw an analogy, this is like observing that on some days everybody on the street is carrying open umbrellas and on other days not, and inferring that the people on the street have a preference for everyone having their umbrellas open together (and the model would then predict that if one person opens an umbrella on a sunny day, everybody else will too).

To the authors credit, they do make a brief attempt to present empirical evidence for their optimization view, stating succinctly: "The high prediction accuracy of the learned policy provides evidence that real population behavior can be understood and modeled as the result of an emergent population-level optimization with respect to a reward function."

Needless to say, this one-sentence argument for a highly controversial scientific claims falls flat on closer inspection.

Setting aside the issues of correlation versus causation, predictive accuracy does not in and of itself provide scientific plausibility.

When an n-gram model produces text that is in the style of a particular writer, we do not conclude that the writer must have been composing based on the n-gram's generative mechanism.

Predictive accuracy only provides evidence when combined in the first place with scientific plausibility through other avenues of evidence.

The authors could attempt to address these issues by making what is called an "as-if" argument,

but it's not even clear such an argument could work here in general.

With all this in mind, it would be more instructive to show that the inference method the authors introduce could infer the correct utility functions used in standard mean field games, such as modeling traffic congestion and the Mexican wave.

-- All that said, the general approach taken in the authors' work is highly promising,

and there are many fruitful directions I would be exicted to see this work taken --- e.g., combining endogenous and exogenous rewards or looking at more complex applications.

As a technical contribution, the paper is wonderful,

and I would enthusiastically support acceptance.

The authors simply either need to be much more careful with the scientific claims about collective behavior they make, or limit the scope of the contribution of the paper to be modeling / inference  in the area of collective behavior.

Mean field games are an important class of models in collective behavior,

and being able to infer their parameters is a nice step forward purely due to the importance of that class of games.

Identifying where the authors' inference method could be applied to draw valid scientific conclusions about collective behavior could then be an avenue for future work.

Examples of plausible scientific applications might include parameter inference in settings where mean field games are already typically applied in order to improve the fit of those models or to learn about trade-offs people make in their utility functions in those settings.

-- Other minor comments: - (Introduction) It is not clear at all how the Arab Spring, Black Lives Matter, and fake news are similar --- i.e., whether a single model could provide insight into these highly heterogeneous events

--- nor is it clear what end the authors hope to achieve by modeling them

--- the ethics of modeling protests in a field crowded with powerful institutional actors is worth carefully considering.

- If I understand correctly, the fact that the authors assume a factored reward function seems limiting.

Isn't the major benefit of game theory it's ability to accommodate utility functions that depend on the actions of others?

- The authors state that one of their essential insights is that "solving the optimization problem of a single-agent MDP is equivalent to solving the inference problem of an MFG."

This statement feels a bit too cute at the expense of clarity.

The authors perform inference via inverse-RL,

so it's more clear to say the authors are attempting to use statistical inference to figure out what is being optimized.

- The relationship between MFGs and a single-agent MDP is nice and a fine observation, but not as surprising as the authors frame it as.

Any multiagent MDP can be naively represented as a single-agent MDP where the agent has control over the entire population,

and we already know that stochastic games are closely related to MDPs.

It's therefore hard to imagine that there woudn't be some sort of correspondence.

evaluation fact fact evaluation evaluation evaluation evaluation evaluation evaluation evaluation evaluation fact fact fact fact evaluation evaluation evaluation evaluation evaluation request evaluation fact fact fact fact fact fact fact fact fact fact fact evaluation evaluation fact evaluation fact fact fact fact quote request fact evaluation fact evaluation fact fact fact evaluation evaluation request evaluation evaluation evaluation evaluation request evaluation evaluation evaluation evaluation evaluation evaluation evaluation evaluation evaluation fact evaluation fact evaluation evaluation fact fact evaluation


The paper is not anonymized.

In page 2, the first line, the authors revealed [15] is a self-citation

and [15] is not anonumized in the reference list.


This paper introduces a new exploration policy for Reinforcement Learning for agents on the web called "Workflow Guided Exploration".

Workflows are defined through a DSL unique to the domain.

The paper is clear, very well written, and well-motivated.

Exploration is still a challenging problem for RL.

The workflows remind me of options though in this paper they appear to be hand-crafted.

In that sense, I wonder if this has been done before in another domain.

The results suggest that WGE sometimes helps but not consistently.

While the experiments show that DOMNET improves over Shi et al, that could be explained as not having to train on raw pixels or not enough episodes.

fact fact evaluation fact evaluation non-arg fact evaluation


This paper studies the question: Why does SGD on deep network is often successful, despite the fact that the objective induces bad local minima?

The approach in this paper is to study a standard MNN with one hidden layer.

They show that in an overparametrized regime, where the number of parameters is logarithmically larger than the number of parameters in the input, the ratio between the number of (bad) local minima to the number of global minima decays exponentially.

They show this for a piecewise linear activation function, and input drawn from a standard Normal distribution.

Their improvement over previous work is that the required overparameterization is fairly moderate, and that the network that they considered is similar to ones used in practice.

This result seems interesting,

although it is clearly not sufficient to explain even the success on the setting studied in this paper,

since the number of minima of a certain type does not correspond to the probability of the SGD ending in one:

to estimate the latter, the size of each basin of attraction should be taken into account.

The authors are aware of this point and mention it as a disadvantage.

However, since this question in general is a difficult one,

any progress might be considered interesting.

Hopefully, in future work it would be possible to also bound the probability of starting in one of the basins of attraction of bad local minima.

The paper is well written and well presented,

and the limitations of the approach, as well as its advantages over previous work, are clearly explained.

As I am not an expert on the previous works in this field, my judgment relies mostly on this work and its representation of previous work.

I did not verify the proofs in the appendix.

fact fact fact fact evaluation evaluation evaluation fact fact fact evaluation evaluation evaluation evaluation evaluation non-arg non-arg


At the heart of the paper, there is a single idea: to decouple the weight decay from the number of steps taken by the optimization process (the paragraph at the end of page 2 is the key to the paper).

This is an important and largely overlooked area of implementation

and most off-the-shelf optimization algorithms, unfortunately, miss this point, too.

I think that the proposed implementation should be taken seriously, especially in conjunction with the discussion that has been carried out with the work of Wilson et al., 2017

The introduction does a decent job explaining why it is necessary to pay attention to the norm of the weights as the training progresses within its scope.

However, I would like to add a couple more points to the discussion: - "Optimal weight decay is a function (among other things) of the total number of epochs / batch passes."

in principle, it is a function of weight updates.

Clearly, it depends on the way the decay process is scheduled.

However, there is a bad habit in DL where time is scaled by the number of epochs rather than the number of weight updates which sometimes lead to misleading plots (for instance, when comparing two algorithms with different batch sizes).

- Another ICLR 2018 submission has an interesting take on the norm of the weights and the algorithm

Figure 3 shows the histograms of SGD/ADAM with and without WD (the *un-fixed* version),

and it clearly shows how the landscape appear misleadingly different when one doesn't pay attention to the weight distribution in visualizations.

- In figure 2, it appears that the training process has three phases, an initial decay, a steady progress, and a final decay that is more pronounced in AdamW.

This final decay also correlates with the better test error of the proposed method.

This third part also seems to correspond to the difference between Adam and AdamW through the way they branch out after following similar curves.

One wonders what causes this branching and whether the key the desired effects are observed at the bottom of the landscape.

- The paper concludes with "Advani & Saxe (2017) analytically showed that in the limited data regime of deep networks the presence of eigenvalues that are zero forms a frozen subspace in which no learning occurs and thus smaller (e.g., zero) initial weight norms should be used to achieve best generalization results."

Related to this there is another ICLR 2018 submission

figure 1 shows that the eigenvalues of the Hessian of the loss have zero forms at the bottom of the landscape, not at the beginning.

Back to the previous point, maybe that discussion should focus on the second and third phases of the training, not the beginning.

- Finally, it would also be interesting to discuss the relation of the behavior of the weights at the last parts of the training and its connection to pruning.

I'm aware that one can easily go beyond the scope of the paper by adding more material.

Therefore, it is not completely reasonable to expect all such possible discussions to take place at once.

The paper as it stands is reasonably self-contained and to the point.

Just a minor last point that is irrelevant to the content of the work: The slash punctuation mark that is used to indicate 'or' should be used without spaces as in 'epochs/batch'.

fact evaluation evaluation evaluation reference evaluation quote fact fact evaluation evaluation reference fact evaluation fact fact fact request fact fact reference fact request request evaluation evaluation evaluation request


The paper takes an interesting approach to solve the existing problems of GAN training, using Coulomb potential for addressing the learning problem.

It is also well written with a clear presentation of the motivation of the problems it is trying to address, the background and proves the optimality of the suggested solution.

My understanding and validity of the proof is still an educated guess.

I have been through section A.2 , but I'm unfamiliar with the earlier literature on the similar topics so I would not be able to comment on it.

Overall, I think this is a good paper that provides a novel way of looking at and solving problems in GANs.

I just had a couple of points in the paper that I would like some clarification on :

* In section 2.2.1 : The notion of the generated a_i not disappearing is something I did not follow.

What does it mean for a generated sample to "not disappear" ?

and this directly extends to the continuity equation in (2).

* In section 1 : in the explanation of the 3rd problem that GANs exhibit i.e.  the generator not being able to generalize the distribution of the input samples, I was hoping if you could give a bit more motivation as to why this happens.

I don't think this needs to be included in the paper,

but would like to have it for a personal clarification.

evaluation evaluation non-arg non-arg evaluation evaluation evaluation request fact request evaluation request