This paper proposes an empirical measure of the intrinsic dimensionality of a neural network problem.

Taking the full dimensionality to be the total number of parameters of the network model, the authors assess intrinsic dimensionality by randomly projecting the network to a domain with fewer parameters (corresponding to a low-dimensional subspace within the original parameter), and then training the original network while restricting the projections of its parameters to lie within this subspace.

Performance on this subspace is then evaluated relative to that over the full parameter space (the baseline).

As an empirical standard, the authors focus on the subspace dimension that achieves a performance of 90% of the baseline.

The authors then test out their measure of intrinsic dimensionality for fully-connected networks and convolutional networks, for several well-known datasets,

and draw some interesting conclusions.

Pros:* This paper continues the recent research trend towards a better characterization of neural networks and their performance.

The authors show a good awareness of the recent literature,

and to the best of my knowledge, their empirical characterization of the number of latent parameters is original.

* The characterization of the number of latent variables is an important one,

and their measure does perform in a way that one would intuitively expect.

For example, as reported by the authors, when training a fully-connected network on the MNIST image dataset, shuffling pixels does not result in a change in their intrinsic dimensionality.

For a convolutional network the observed 3-fold rise in intrinsic dimension is explained by the authors as due to the need to accomplish the classification task while respecting the structural constraints of the convnet.

* The proposed measures seem very practical -

training on random projections uses far fewer parameters than in the original space (the baseline),

and presumably the cost of determining the intrinsic dimensionality would presumably be only a fraction of the cost of this baseline training.

* Except for the occasional typo or grammatical error, the paper is well-written and organized.

The issues are clearly identified, for the most part (but see below...).

Cons:* In the main paper, the authors perform experiments and draw conclusions without taking into account the variability of performance across different random projections.

Variance should be taken into account explicitly, in presenting experimental results and in the definition and analysis of the empirical intrinsic dimension itself.

How often does a random projection lead to a high-quality solution, and how often does it not?

* The authors are careful to point out that training in restricted subspaces cannot lead to an optimal solution for the full parameter domain unless the subspace intersects the optimal solution region (which in general cannot be guaranteed).

In their experiments (FC networks of varying depths and layer widths for the MNIST dataset), between projected and original solutions achieving 90% of baseline performance, they find an order of magnitude gap in the number of parameters needed.

This calls into question the validity of random projection as an empirical means of categorizing the intrinsic dimensionality of a neural network.

* The authors then go on to propose that compression of the network be achieved by random projection to a subspace of dimensionality greater than or equal to the intrinsic dimension.

However, I don't think that they make a convincing case for this approach.

Again, variation is the difficulty:

two different projective subspaces of the same dimensionality can lead to solutions that are extremely different in character or quality.

How then can we be sure that our compressed network can be reconstituted into a solution of reasonable quality, even when its dimensionality greatly exceeds the intrinsic dimension?

* The authors argue for a relationship between intrinsic dimensionality and the minimum description length (MDL) of their solution,

in that the intrinsic dimensionality should serve as an upper bound on the MDL.

However they don't formally acknowledge that there is no standard relationship between the number of parameters and the actual number of bits needed to represent the model -

it varies from setting to setting, with some parameters potentially requiring many more bits than others.

And given this uncertain connection, and given the lack of consideration given to variation in the proposed measure of intrinsic dimensionality, it is hard to accept that "there is some rigor behind" their conclusion that LeNet is better than FC networks for classification on MNIST

because its empirical intrinsic dimensionality score is lower.

* The experimental validation of their measure of intrinsic dimension could be made more extensive.

In the main paper, they use three image datasets - MNIST, CIFAR-10 and ImageNet.

In the supplemental information, they report intrinsic dimensions for reinforcement learning and other training tasks on four other sets.

Overall, I think that this characterization does have the potention to give insights into the performance of neural networks, provided that variation across projections is properly taken into account.

For now, more work is needed.

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


While I acknowledge that training generative models with binary latent variables is hard,

I'm not sure this paper really makes valuable progress in this direction.

The only results that seem promising are those on binarized MNIST, for the non-convolutional architecture,

and this setting isn't particularly exciting.

All other experiments seem to suggest that the proposed model/algorithm is behind the state of the art.

Moreover, the proposed approach is fairly incremental, compared to existing work on RWS, VIMCO, etc.

So while this work seem to have been seriously and thoughtfully executed,

I think it falls short of the ICLR acceptance bar.

evaluation evaluation evaluation evaluation fact evaluation evaluation evaluation


Summary This paper presents Neural Process Networks, an architecture for capturing procedural knowledge stated in texts that makes use of a differentiable memory, a sentence and word attention mechanism, as well as learning action representations and their effect on entity representations.

The architecture is tested for tracking entities in recipes, as well as generating the natural language description for the next step in a recipe.

It is compared against a suit of baselines, such as GRUs, Recurrent Entity Networks, Seq2Seq and the Neural Checklist Model.

While I liked the overall paper,

I am worried about the generality of the model, the qualitative analysis, as well as a fair comparison to Recurrent Entity Networks and non-neural baselines.

Strengths I believe the authors made a good effort in comparing against existing neural baselines (Recurrent Entity Networks, Neural Checklist Model) *for their task*.

That said, it is unclear to me how generally applicable the method is and whether the comparison against Recurrent Entity Networks is fair (see Weaknesses).

I like the ablation study.

Weaknesses While I find the Neural Process Networks architecture interesting

and I acknowledge that it outperforms Recurrent Entity Networks for the presented tasks,

after reading the paper it is not clear to me how generally applicable the architecture is.

Some design choices seem rather tailored to the task at hand (manual collection of actions MTurk annotation in section 3.1)

and I am wondering where else the authors see their method being applied given that the architecture relies on all entities and actions being known in advance.

My understanding is that the architecture could be applied to bAbI and CBT (the two tasks used in the Recurrent Entity Networks paper).

If that is the case, a fair comparison to Recurrent Entity Networks would have been to test against Recurrent Entity Networks on these tasks too.

If they the architecture cannot be applied in these tasks, the authors should explain why.

I am not convinced by the qualitative analysis.

Table 2 tells me that even for the best model the entity selection performance is rather unreliable (only 55.39% F1),

yet all examples shown in Table 3 look really good, missing only the two entities oil (1) and sprinkles (3).

This suggests that these examples were cherry-picked

and I would like to see examples that are sampled randomly from the dev set.

I have a similar concern regarding the generation task.

First, it is not mentioned where the examples in Table 6 are taken from – is it the train, dev or test set?

Second, the overall BLEU score seems quite low even for the best model,

yet the examples in Table 6 look really good.

In my opinion, a good qualitative analysis should also discuss failure cases.

Since the BLEU score is so low here,

you might also want to compare perplexity of the models.

The qualitative analysis in Table 5 is not convincing either.

In Appendix A.1 it is mentioned that word embeddings are initialized from word2vec trained on the training set.

My suspicion is that one would get the clustering in Table 4 already from those pretrained vectors, maybe even when pretrained on the Google news corpus.

Hence, it is not clear what propagating gradients through the Neural Process Networks into the action embeddings adds, or put differently, why does it have to be a differentiable architecture when an NLP pipeline might be enough?

This could easily be tested by another ablation where action embeddings are pretrained using word2vec and then fixed during training of the Neural Process Network.

Moreover, in 3.3 it is mentioned that even the Action Selection is pretrained,

which makes me wonder what is actually trained jointly in the architecture and what is not.

I think the difficulty of the task at hand needs to be discussed at some point, ideally early in the paper.

Until examples on page 7 are shown, I did not have a sense for why a neural architecture is chosen.

For example, in 2.3 it is mentioned that for "wash and cut" the two functions fwash and fcut need to be selected.

For this example, this seems trivial

as the functions have the same name

(and you could even have a function per name!).

As far as I understand, the point of the action selector is to only have a fixed number of learned actions and multiple words (cut, slice etc.) should select the same action fcut.

Otherwise (if there is little language ambiguity) I would not see the need for a complex neural architecture.

Related to that, a non-neural baseline for the entity selection task that in my opinion definitely needs to be added is extracting entities using a pretrained NER system and returning all of them as the selection.

p2 Footnote 1: So if I understand this correctly, this work builds upon a dataset of over 65k recipes from Kiddon et al. (2016), but only for 875 of those detailed annotations were created?

Minor Comments p1: The statement "most natural language understanding algorithms do not have the capacity …" should be backed by reference.

p2: "context representation ht" – I would directly mention that this is a sentence encoding.

p3: 2.4: I have the impression what you are describing here is known in the literature as entity linking.

p3 Eq.3: Isn't c3*0 always a vector of zeros?

p4 Eq.6: W4 is an order-3 tensor, correct?

p4 Eq.8: What is YC and WC here and what are their dimensions?

I am confused by the softmax,

as my understanding (from reading the paragraph on the Action Selection Loss on p.5) was that the expression in the softmax here is a scalar (as it is done for every possible action),

so this should be a sigmoid to allow for multiple actions to attain a probability of 1?

p5: "See Appendix for details" -> "see Appendix C for details"

p5 3.3: Could you elaborate on the heuristic for extracting verb mentions?

Is only one verb mention per sentence extracted?

p5: "trained to minimize cross-entropy loss" -> "trained to minimize the cross-entropy loss"

p5 3.3: What is the global loss?

p6: "been read (§2.5." -> "been read (§2.5)."

p6: "We encode these vectors using a bidirectional GRU" – I think you composing a fixed-dimensional vector from the entity vectors?

What's eI?

p7: For which statement is (Kim et al. 2016) the reference?

Surely, they did not invent the Hadamard product.

p8: "Our model, in contrast" use" -> "Our model, in contrast, uses".

p8 Related Work: I think it is important to mention that existing architectures such as Memory Netwroks could, in principle, learn to track entities and devote part of their parameters to learn the effect of actions.

What Neural Process Networks are providing is a strong inductive bias for tracking entities and learning the effect of actions that is useful for the task considered in this paper.

As mentioned in the weaknesses, this might however come at the price of a less general model,

which should be discussed.

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


This paper presents a novel method for spike based learning that aims at reducing the needed computation during learning and testing when classifying temporal redundant data.

This approach extends the method presented on Arxiv on Sigma delta quantized networks

(Peter O’Connor and Max Welling. Sigma delta quantized networks. arXiv preprint arXiv:1611.02024, 2016b.).

Overall, the paper is interesting and promising;

only a few works tackle the problem of learning with spikes showing the potential advantages of such form of computing.

The paper, however, is not flawless.

The authors demonstrate the method on just two datasets, and effectively they show results of training only for Feed-Forward Neural Nets

(the authors claim that “the entire spiking network end-to-end works” referring to their pre-trained VGG19,

but this paper presents only training for the three top layers).

Furthermore, even if suitable datasets are not available, the authors could have chosen to train different architectures.

The first dataset is the well-known benchmark MNIST also presented in a customized Temporal-MNIST.

Although it is a common base-line, some choices are not clear:

why using a FFNN instead that a CNN which performs better on this dataset;

how data is presented in terms of temporal series –

this applies to the Temporal MNIST too;

why performances for Temporal MNIST – which should be a more suitable dataset — are worse than for the standard MNIST;

what is the meaning of the right column of Figure 5

since it’s just a linear combination of the GOps results.

For the second dataset, some points are not clear too:

why the labels and the pictures seem not to match (in appendix E);

why there are more training iterations with spikes w.r.t. the not-spiking case.

Overall, the paper is mathematically sound,

except for the “future updates” meaning which probably deserves a clearer explanation.

Moreover, I don’t see why the learning rule equations (14-15) are described in the appendix,

while they are referred constantly in the main text.

The final impression is that the problem of the dynamical range of the hidden layer activations is not fully resolved by the empirical solution described in Appendix D:

perhaps this problem affects CCNs more than FFN.

Finally, there are some minor issues here and there

(the authors show quite some lack of attention for just 7 pages):

-	Two times “get” in “we get get a decoding scheme” in the introduction;

-	Two times “update” in “our true update update as” in Sec. 2.6;

-	Pag3 correct the capital S in 2.3.1

-	Pag4 Figure 1 increase font size (also for Figure2);

close bracket after Equation 3;

N (number of spikes) is not defined

-	Pag5 “one-hot” or “onehot”;

-	in the inline equation the sum goes from n=1 to S, while in eq.(8) it goes from n=1 to N;

-	Eq(10)(11)(12) and some lines have a typo (a \cdot) just before some of the ws;

-	Pag6 k_{beta} is not defined in the main text;

-	Pag7 there are two “so that” in 3.1;

capital letter “It used 32x10^12..”;

beside, here, why do not report the difference in computation w.r.t. not-spiking nets?

-	Pag7 in 3.2 “discussed in 1” is section 1?

-	Pag14 Appendix E, why the labels don’t match the pictures;

-	Pag14 Appendix F, explain better the architecture used for this experiment.

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


This paper examines the effects of RL in an augmented action space which includes sequences of actions (e.g. meta actions) as well as the primitive actions defined by the MDP.

The authors extend a GPU-based A3C implementation to include meta actions

and show that their algorithm can achieve better sample complexity / and higher performance in most cases.

The paper is well written,

but fails to mention the relationship between meta-actions and the Options framework (Sutton et al 99).

In particular, it seems that meta-actions can just be viewed as a set of predefined options given to the agent.

Much prior work has studied how to combine options with Deep RL.

To name a few: Multi-Level Discovery of Deep Options (Fox et al 17),

Classifying Options for Deep RL (Arulkumaran 16),

and Deep Exploration via Bootstrapped DQN (Osband et al).

The former even learns the options rather than pre-defining them.

This connection needs to be made explicit.

I have concerns regarding the results in this paper:

•	 Why on Qbert is the switching agent able to do so much better than both IU and DU?

I suspect the curves may not be averaged over enough trials and results may be noisy,

as it seems this shouldn’t be possible.

Results curves should show the standard deviation or variance of the 3 runs.

•	I am concerned this approach will not scale to games that have more actions than the 4 games explored.

The concern is that A4C exponentially increases the size of the action space as a function of k.

Cartpole as well as the explored Atari games all have relatively small action spaces,

so I think it is critical to show that it scales to games with larger spaces as well.

My concern is that in larger actions spaces, the gains A4C gets from meta-actions will be outweighed by the difficulty of having to learn with so many different actions.

•	What is the value for k used in Atari experiments?

Overall, I was very excited about this paper after reading the introduction.

I really like the idea of allowing the network to decide on sequences of actions,

and I think many games do have opportunity to identify and re-use combos of primitive actions (e.g. to stay between lanes in Beam Rider).

However, I don’t think the architecture, algorithm, and results live up to this motivation.

Simply augmenting the action space with all possible sequences of actions begs for a better solution.

Pros:•	The authors show that in certain domains, exploration can be aided by pre-defined meta actions.

•	The authors introduce an algorithm to squeeze more gradient updates out of a meta-action (DU-A4C).

This is related to the insight that meta actions can be thought of as sequences of primitive actions.

Cons:•	Relationship to Options is not identified.

•	Results are only given for games with small action spaces.

Unclear how the method scales to larger action spaces.

•	Method for augmenting action space is not particularly interesting.

•	Heuristic switching is somewhat undesirable.

It would be nice to understand why DU stops working well and how to improve it.

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


This paper proposed to jointly train a multilingual skip-gram model and a cross-lingual sentence similarity model to construct sentence embeddings.

They used cross-lingual classification tasks for evaluation.

This idea is fairly simple but interesting.

Their results on some language pairs showed that the joint training is effective

(results on table 1 showed that sent-LSTM worked best with dim=128).

The downside of this paper is that their results could not outperform state-of-the-art results.

Some detailed comments: -	The authors should weaken some of the statements, e.g. ‘since our multilingual skip-gram and cross-lingual sentence similarity models are trained jointly, they can inform each other through the shared word embedding layer and promote the compositionality of learned word embeddings at training time’.

Actually, there are no experimental results and evidences in this paper supporting this statement.

-	I don’t  see that ‘Amenable to Multi-task modeling’ is a contribution of this paper.

The authors should report additional experimental results to prove this statement.

fact fact evaluation fact fact evaluation request fact evaluation request


Summary: The paper proposes a learnable skimming mechanism for RNN.

The model decides whether to send the word to a larger heavy-weight RNN or a light-weight RNN.

The heavy-weight and the light-weight RNN each controls a portion of the hidden state.

The paper finds that with the proposed skimming method, they achieve a significant reduction in terms of FLOPS.

Although it doesn’t contribute to much speedup on modern GPU hardware, there is a good speedup on CPU,

and it is more power efficient.

Contribution: - The paper proposes to use a small RNN to read unimportant text.

Unlike (Yu et al., 2017), which skips the text, here the model decides between small and large RNN.

Pros: - Models that dynamically decide the amount of computation make intuitive sense and are of general interests.

- The paper presents solid experimentation on various text classification and question answering datasets.

- The proposed method has shown reasonable reduction in FLOPS and CPU speedup with no significant accuracy degradation (increase in accuracy in some tasks).

- The paper is well written, and the presentation is good.

Cons: - Each model component is not novel.

The authors propose to use Gumbel softmax, but does compare other gradient estimators.

It would be good to use REINFORCE to do a fair comparison with (Yu et al., 2017 ) to see the benefit of using small RNN.

- The authors report that training from scratch results in unstable skim rate, while Half pretrain seems to always work better than fully pretrained ones.

This makes the success of training a bit adhoc,

as one need to actively tune the number of pretraining steps.

- Although there is difference from (Yu et al., 2017),

the contribution of this paper is still incremental.

Questions: - Although it is out of the scope for this paper to achieve GPU level speedup,

I am curious to know some numbers on GPU speedup.

- One recommended task would probably be text summarization, in which the attended text can contribute to the output of the summary.

Conclusion: - Based on the comments above, I recommend Accept

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


The paper proposes a technique for training quantized neural networks, where the precision (number of bits) varies per layer and is learned in an end-to-end fashion.

The idea is to add two terms to the loss, one representing quantization error, and the other representing the number of discrete values the quantization can support (or alternatively the number of bits used).

Updates are made to the parameter representing the # of bits via the sign of its gradient.

Experiments are conducted using a LeNet-inspired architecture on MNIST and CIFAR10.

Overall, the idea is interesting, as providing an end-to-end trainable technique for distributing the precision across layers of a network would indeed be quite useful.

I have a few concerns: First, I find the discussion around the training methodology insufficient.

Inherently, the objective is discontinuous since # of bits is a discrete parameter.

This is worked around by updating the parameter using the sign of its gradient.

This is assuming the local linear approximation given by the derivative is accurate enough one integer away;

this may or may not be true,

but it's not clear and there is little discussion of whether this is reasonable to assume.

It's also difficult for me to understand how this interacts with the other terms in the objective (quantization error and loss).

We'd like the number of bits parameter to trade off between accuracy (at least in terms of quantization error, and ideally overall loss as well) and precision.

But it's not at all clear that the gradient of either the loss or the quantization error w.r.t. the number of bits will in general suggest increasing the number of bit (thus requiring the bit regularization term).

This will clearly not be the case when the continuous weights coincide with the quantized values for the current bit setting.

More generally, the direction of the gradient will be highly dependent on the specific setting of the current weights.

It's unclear to me how effectively accuracy and precision are balanced by this training strategy,

and there isn't any discussion of this point either.

I would be less concerned about the above points if I found the experiments compelling.

Unfortunately, although I am quite sympathetic to the argument that state of the art results or architectures aren't necessary for a paper of this kind,

the results on MNIST and CIFAR10 are so poor that they give me some concern about how the training was performed and whether the results are meaningful.

Performance on MNIST in the 7-11% test error range is comparable to a simple linear logistic regression model; for a CNN that is extremely bad.

Similarly, 40% error on CIFAR10 is worse than what some very simple fully connected models can achieve.

Overall, while I like the and think the goal is good,

I think the motivation and discussion for the training methodology is insufficient, and the empirical work is concerning.

I can't recommend acceptance.

fact fact fact fact evaluation evaluation fact fact fact evaluation evaluation evaluation fact evaluation evaluation fact evaluation fact evaluation evaluation evaluation evaluation fact evaluation evaluation evaluation


Monte-Carlo Tree Search is a reasonable and promising approach to hyperparameter optimization or algorithm configuration in search spaces that involve conditional structure.

This paper must acknowledge more explicitly that it is not the first to take a graph-search approach.

The cited work related to SMAC and Hyperopt / TPE addresses this problem similarly.

The technique of separating a description language from the optimization algorithm is also used in both of these projects / lines of research.

The [mis-cited] paper titled “Making a science of model search …” is about using TPE to configure 1, 2, and 3 layer convnets for several datasets, including CIFAR-10.

SMAC and Hyperopt have been used to search large search spaces involving pre-processing and classification algorithms (e.g. auto-sklearn, autoweka, hyperopt-sklearn).

There have been near-annual workshops on AutoML and Bayesian optimization at NIPS and ICML (see e.g. automl.org).

There is a benchmark suite of hyperparameter optimization problems that would be a better way to evaluate MCTS as a hyperparameter optimization algorithm: http://www.ml4aad.org/automl/hpolib/

evaluation request evaluation fact fact fact fact evaluation


(Score before author revision: 4)\n (Score after author revision: 7)\n\n

I think the authors have taken both the feedback of reviewers as well as anonymous commenters thoroughly into account, running several ablations as well as reporting nice results on an entirely new dataset (MultiNLI)

where they show how their multi level fusion mechanism improves a baseline significantly.

I think this is nice

since it shows how their mechanism helps on two different tasks (question answering and natural language inference).\n\n

Therefore I would now support accepting this paper.\n\n

------------(Original review below) -----------------------\n\n

The authors present an enhancement to the attention mechanism called \"multi-level fusion\"

that they then incorporate into a reading comprehension system.

It basically takes into account a richer context of the word at different levels in the neural net to compute various attention scores.\n\n

i.e. the authors form a vector \"HoW\" (called history of the word),

that is defined as a concatenation of several vectors:\n\n HoW_i = [g_i, c_i, h_i^l, h_i^h]\n\nwhere g_i = glove embeddings, c_i = COVE embeddings <b> there is no predicate put with 15 </b>

(McCann et al. 2017),

and h_i^l and h_i^h are different LSTM states for that word.\n\n

The attention score is then a function of these concatenated vectors i.e. \\alpha_{ij} = \\exp(S(HoW_i^C, HoW_j^Q))\n\n <b> it cannot stay by itself merge with 21 </b>

Results on SQuAD show a small gain in accuracy (75.7->76.0 Exact Match).

The gains on the adversarial set are larger

but that is because some of the higher performing, more recent baselines don't seem to have adversarial numbers.\n\n

The authors also compare various attention functions (Table 5) showing a particular one (Symmetric + ReLU) works the best.\n\n

Comments:\n\n-I feel overall the contribution is not very novel.

The general neural architecture that the authors propose in Section 3 is generally quite similar to the large number of neural architectures developed for this dataset

(e.g. some combination of attention between question/context and LSTMs over question/context).

The only novelty is these \"HoW\" inputs to the extra attention mechanism

that takes a richer word representation into account.\n\n

-I feel the model is seems overly complicated for the small gain (i.e. 75.7->76.0 Exact Match),

especially on a relatively exhausted dataset (SQuAD) that is known to have lots of pecularities (see anonymous comment below).

It is possible the gains just come from having more parameters.\n\n

-The authors (on page 6) claim that that by running attention multiple times with different parameters but different inputs (i.e. \\alpha_{ij}^l, \\alpha_{ij}^h, \\alpha_{ij}^u) it will learn to attend to \"different regions for different level\".

However, there is nothing enforcing this

and the gains just probably come from having more parameters/complexity.

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


In this paper, the authors investigate variance reduction techniques for agents with multi-dimensional policy outputs, in particular when they are conditionally independent ('factored').

With the increasing focus on applying RL methods to continuous control problems and RTS type games, this is an important problem

and this technique seems like an important addition to the RL toolbox.

The paper is well written, the method is easy to implement,

and the algorithm seems to have clear positive impact on the presented experiments.

- The derivations in pages 4-6 are somewhat disconnected from the rest of the paper:

the optimal baseline derivation is very standard (even if adapted to the slightly different situation situated here),

and for reasons highlighted by the authors in this paper, they are not often used;

the 'marginalized' baseline is more common, and indeed, the authors adopt this one as well.

In light of this (and of the paper being quite a bit over the page limit)-

is this material (4.2->4.4) mostly not better suited for the appendix?

Same for section 4.6 (which I believe is not used in the experiments).

- The experimental section is very strong;

regarding the partial observability experiments, assuming actions are here factored as well, I could see four baselines

(two choices for whether the baseline has access to the goal location or not, and two choices for whether the baseline has access to the vector $a_{-i}$).

It's not clear which two baselines are depicted in 5b -

is it possible to disentangle the effect of providing $a_{-i}$ and the location of the hole to the baseline?

(side note: it is an interesting idea to include information not available to the agent as input to the baseline though it does feel a bit 'iffy' ;

the agent requires information to train,

but is not provided the information to act.

Out of curiosity, is it intended as an experiment to verify the need for better baselines?

Or as a 'fair' training procedure?)

- Minor: in equation 2- is the correct exponent not t'?

Also since $\rho_\pi$ is define with a scaling $(1-\gamma)$ (to make it an actual distribution),

I believe the definition of $\eta$ should also be multiplied by $(1-\gamma)$ (as well as equation 2).

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


The paper proposes a new evaluation measure for evaluating GANs.

Specifically, the paper proposes generating synthetic images using GAN, training a classifier (for an auxiliary task, not the real vs fake discriminator) and measuring the performance of this classifier on held out real data.

While the idea of using a downstream classification task to evaluate the quality of generative models has been explored before  (e.g. semi-supervised learning),

I think that this is the first paper to evaluate GANs using such an evaluation metric.

I'm not super convinced that this is an useful evaluation metric as the absolute number is somewhat to interpret and dependent on the details of the classifier used.

The results in Table 1 change quite a bit depending on the classifier.

It would be useful to add a discussion of the failure modes of the proposed metric.

It seems like a generator which generates samples close to the classification boundary (but drops examples far away from the boundary) could still achieve a high score under this metric.

In the experiments, were different architectures used for different GAN variants?

I think the mode-collapse evaluation metrics in MR-GAN are worth discussing in Section 2.1

Mode Regularized Generative Adversarial Networks https://arxiv.org/abs/1612.02136

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


There is no scientific consensus on whether quantum annealers such as the D-Wave 2000Q that use the transverse-field Ising models yield any gains over classical methods

(c.f. https://arxiv.org/abs/1703.00622).

However, it is an exciting research area

and this paper is an interesting demonstration of the feasibility of using quantum annealers for reinforcement learning.

This paper builds on Crawford et al. (2016), an unpublished preprint, who develop a quantum Boltzmann machine reinforcement learning algorithm (QBM-RL).

A QBM consists of adding a transverse field term to the RBM Hamiltonian (negative log likelihood),

but the benefits of this for unsupervised tasks are unclear

(c.f. https://arxiv.org/abs/1601.02036, another unpublished preprint).

QBM-RL consists of using a QBM to model the state-action variables:

it is an undirected graphical model whose visible nodes are clamped to observed state-action pairs.

The hidden nodes model dependencies between states and actions, and the weights of the model are updated to maximize the free energy or Q function (value of the state-action pair).

The authors extend QBM-RL to work with quantum annealers such as the D-Wave 2000Q, which has a specific bipartite graph structure and requires special consideration

because it can only yield samples of hidden variables in a fixed basis.

To overcome this, the authors develop a Suzuki-Trotter expansion and call it 'replica stacking', where a classical Hamiltonian in one dimension higher is used to approximate the quantum Hamiltonian.

This enables the use of quantum annealers.

The authors compare their method to standard baselines in a grid world environment.

Overall, I do not want to criticize the work.

It is an interesting proof of concept.

But given the high price of quantum annealers, limited applicability of the technique, and unclear benefits of the authors' method, I do not think it is relevant to this specific conference.

It may be better suited to a workshop specific to quantum machine learning methods.

======================================= + please add an algorithm box for your method.

It deviates significantly from QBM-RL.

For example, something like: (1) init weights of boltzmann machine randomly (2) sample c_eff ~ C from the pool of configurations sampled from the transverse-field Ising model using a quantum annealer with chimera graph (3) using the samples, calculate effective classical hamiltonian used to approximate the quantum system (4) use the weight update rules derived from Bellman equations (spell out the rules).

+ moving the details of sampling into the appendix would help;

they are not important for understanding the main ingredients of your method

There are so many moving parts in your system,

and someone without a physics background will struggle to understand it.

Clarifying the algorithm in terms familiar to machine learning researchers will go a long way toward helping people understand your method.

+ the benefits of your method is unclear -

it looks like the method works, but doesn't outperform the others.

this is fine,

but it is better to be straightforward about this and bill it as a 'proof of concept'

+ perhaps consider rebranding the paper as something like 'RL using replica stacking for sampling from quantum boltzmann machines with quantum annealers'.

Elucidating why replica stacking is a crucial contribution of your work would be helpful, and could be of broad interest in the machine learning community.

Right now it is too dense to be useful for the average person without a physics background:

what difficulties are intrinsic to a quantum Hamiltonian?

What is the intuition behind the Suzuki-Trotter decomposition you develop?

What is the 'quantum' Boltzmann machine in machine learning terms (hidden-hidden connections in an undirected graphical model!)?

What is replica-stacking in graphical model terms

(this would be a great ML contribution in its own right!)?

Really spelling these things out in detail (or in the appendix) would help

========================================== 1) eq 14 is malformed

2) references are not well-formatted

3) need factor of 1/2 to avoid double counting in sums over nearest neighbors (please be precise)

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


The paper proposes to improve the kernel approximation of random features by using quadratures, in particular, stochastic spherical-radial rules.

The quadrature rules have smaller variance given the same number of random features,

and experiments show its reconstruction error and classification accuracies are better than existing algorithms.

It is an interesting paper,

but it seems the authors are not aware of some existing works [1, 2] on quadrature for random features.

Given these previous works, the contribution and novelty of the paper is limited.

[1] Francis Bach. On the Equivalence between Kernel Quadrature Rules and Random Feature Expansions. JMLR, 2017.

[2] Tri Dao, Christopher De Sa, Christopher Ré. Gaussian Quadrature for Kernel Features. NIPS 2017

fact fact fact evaluation fact evaluation reference reference


The authors consider new attacks for generating adversarial samples against neural networks.

In particular, they are interested in approximating gradient-based white-box attacks such as FGSM in a black-box setting by estimating gradients from queries to the classifier.

They assume that the attacker is able to query, for any example x, the vector of probabilities p(x) corresponding to each class.

Given such query access it’s trivial to estimate the gradients of p using finite differences.

As a consequence one can implement FGSM using these estimates assuming cross-entropy loss, as well as a logit-based loss.

They consider both iterative and single-step FGSM attacks in the targeted (i.e. the adversary’s goal is to switch the example’s label to a specific alternative label) and un-targeted settings (any mislabelling is a success).

They compare themselves to transfer black-box attacks, where the adversary trains a proxy model and generates the adversarial sample by running a white-box attack on that model.

For a number of target classifiers on both MNIST and CIFAR-10, they show that these attacks outperform the transfer-based attacks, and are comparable to white-box attacks, while maintaining low distortion on the attack samples.

One drawback of estimating gradients using finite differences is that the number of queries required scales with the dimensionality of the examples,

which can be prohibitive in the case of images.

They therefore describe two practical approaches for query reduction — one based on random feature grouping, and the other on PCA (which requires access to training data).

They once again demonstrate the effectiveness of these methods across a number of models and datasets, including models deploying adversarially trained defenses.

Finally, they demonstrate compelling real-world deployment against Clarifai classification models designed to flag “Not Safe for Work” content.

Overall, the paper provides a very thorough experimental examination of a practical black-box attack that can be deployed against real-world systems.

While there are some similarities with Chen et al. with respect to utilizing finite-differences to estimate gradients, I believe the work is still valuable for its very thorough experimental verification, as well as the practicality of their methods.

The authors may want to be more explicit about their claim in the Related Work section that the running time of their attack is “40x” less than that of Chen et al.

While this is believable, there is no running time comparison in the body of the paper.

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


Authors proposed a neural network based machine translation method between two programming languages.

The model is based on both source/target syntax trees and performs an attentional encoder-decoder style network over the tree structure.

The new things in the paper are the task definition and using the tree-style network in both encoder and decoder.

Although each structure of encoder/decoder/attention network is based on the application of some well-known components,

unfortunately, the paper pays much space to describe them.

On the other hand, the whole model structure looks to be easily generalized to other tree-to-tree tasks and might have some potential to contribute this kind of problems.

In experimental settings, there are many shortages of the description.

First, it is unclear that what the linearization method of the syntax tree is,

which could affect the final model accuracy.

Second, it is also unclear what the method to generate train/dev/test data is.

Are those generated completely randomly?

If so, there could be many meaningless (e.g., inexecutable) programs in each dataset.

What is the reasonableness of training such kind of data, or are they already avoided from the data?

Third, the evaluation metrics "token/program accuracy" looks insufficient about measuring the correctness of the program

because it has sensitivity about meaningless differences between identifier names and some local coding styles.

Authors also said that CoffeeScript has a succinct syntax and Javascript has a verbose one without any agreement about what the syntax complexity is.

Since any CoffeeScript programs can be compiled into the corresponding Javascript programs,

we should assume that CoffeeScript is the only subset of Javascript (without physical difference of syntax),

and this translation task may never capture the whole tendency of Javascript.

In addition, authors had generated the source CoffeeScript codes,

which seems that this task is only one of "synthetic" task and no longer capture any real world's programs.

If authors were interested in the tendency of real program translation task, they should arrange the experiment by collecting parallel corpora between some unrelated programming languages using resources in the real world.

Global attention mechanism looks somewhat not suitable for this task.

Probably we can suppress the range of each attention by introducing some prior knowledge about syntax trees (e.g., only paying attention to the descendants in a specific subtree).

Suggestion: After capturing the motivation of the task, I suspect that the traditional tree-to-tree (also X-to-tree) "statistical" machine translation methods still can also work correctly in this task.

The traditional methods are basically based on the rule matching, which constructs a target tree by selecting source/target subtree pairs and arranging them according to the actual connections between each subtree in the source tree.

This behavior might be suitable to transform syntax trees while keeping their whole structure, and also be able to treat the OOV (e.g., identifier names) problem by a trivial modification.

Although it is not necessary, it would like to apply those methods to this task as another baseline if authors are interested in.

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


This paper presents a framework to recover a set of independent mechanisms.

In order to do so it uses a set of experts each one made out of a GAN.

\n\nMy main concern with this work is that I don't see any mechanism in the framework that prevents an expert  (or few of them) to win all examples except its own learning capacities.

p7 authors have also noticed that several experts fail to specialize

and I bet that is the reason why.

\nThus, authors should analyze how well we can have all/most experts specialize in a pool vs expert capacity/architecture.

\nIt would also be great to integrate a direct regularization mechanism in the cost  in order to do so.

Like for example a penalty in how many examples a expert has catched.

\n\nMoreover, the discrimator D  (which is trained to discriminate between real or fake examples) seems to be directly used to tell if an example is throw from the targeted distribution.

It is not the same task.

How D will handle an example far from fake or real ones ?

Why will D answer negatively (or positively) on this example ?

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


This paper introduces a simple correlation-based metric to measure whether filters in neural networks are being used effectively, as a proxy for effective capacity.

The authors then introduce a greedy algorithm

that expands the different layers in a neural network until the metric indicates that additional features will end up not being used effectively.

The application of this algorithm is shown to lead to architectures that differ substantially from hand-designed models with the same number of layers:

most of the parameters end up in intermediate layers, with fewer parameters in earlier and later layers.

This indicates that common heuristics to divide capacity over the layers of a network are suboptimal,

as they tend to put most parameters in later layers.

It's also nice that simpler tasks yield smaller models (e.g. MNIST vs. CIFAR in figure 3).

The experimental section is comprehensive and the results are convincing.

I especially appreciate the detailed analysis of the results (figure 3 is great).

Although most experiments were conducted on the classic benchmark datasets of MNIST, CIFAR-10 and CIFAR-100,

the paper also includes some promising preliminary results on ImageNet,

which nicely demonstrates that the technique scales to more practical problems as well.

That said, it would be nice to demonstrate that the algorithm also works for other tasks than image classification.

I also like the alternative perspective compared to pruning approaches,

which most research seems to have been focused on in the past.

The observation that the cross-correlation of a weight vector with its initial values is a good measure for effective filter use seems obvious in retrospect,

but hindsight is 20/20 and the fact is that apparently this hasn't been tried before.

It is definitely surprising that a simple method like this ends up working this well.

The fact that all parameters are reinitialised whenever any layer width changes seems odd at first,

but I think it is sufficiently justified.

It would be nice to see some comparison experiments as well though,

as the intuitive thing to do would be to just keep the existing weights as they are.

Other remarks: Formula (2) seems needlessly complicated because of all the additional indices.

Maybe removing some of those would make things easier to parse.

It would also help to mention that it is basically just a normalised cross-correlation.

This is mentioned two paragraphs down,

but should probably be mentioned right before the formula is given instead.

page 6, section 3.1: "it requires convergent training of a huge architecture with lots of regularization before complexity can be introduced",

I guess this should be "reduced" instead of "introduced".

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


The paper proposes a technique for quantizing the weights of a neural network, with bit-depth/precision varying on a per-parameter basis.

The main idea is to minimize the number of bits used in the quantization while constraining the loss to remain below a specified upper bound.

This is achieved by formulating an upper bound on the number of bits used via a set of "tolerances";

this upper bound is then minimized while estimating any increase in loss using a first order Taylor approximation.

I have a number of questions and concerns about the proposed approach.

First, at a high level, there are many details that aren't clear from the text.

Quantization has some bookkeeping associated with it: In a per-parameter quantization setup it will be necessary to store not just the quantized parameter, but also the number of bits used in the quantization (takes e.g. 4-5 extra bits), and there will be some metadata necessary to encode how the quantized value should be converted back to floating point (e.g., for 8-bit quantization of a layer of weights, usually the min and max are stored).

From Algorithm 1 it appears the quantization assumes parameters in the range [0, 1].

Don't negative values require another bit?

What happens to values larger than 1?

How are even bit depths and associated asymmetries w.r.t. 0 handled

(e.g., three bits can represent -1, 0, and 1, but 4 must choose to either not represent 0 or drop e.g. -1)?

None of these details are clearly discussed in the paper,

and it's not at all clear that the estimates of compression are correct if these bookkeeping matters aren't taken into account properly.

Additionally the paper implies that this style of quantization has benefits for compute in addition to memory savings.

This is highly dubious,

since the method will require converting all parameters to a standard bit-depth on the fly (probably back to floating point, since some parameters may have been quantized with bit depth up to 32).

Alternatively custom GEMM/conv routines would be required which are impossible to make efficient for weights with varying bit depths.

So there are likely not runtime compute or memory savings from such an approach.

I have a few other specific questions: Are the gradients used to compute \mu computed on the whole dataset or minibatches?

How would this scale to larger datasets?

I am confused by the equality in Equation 8: What happens for values shared by many different quantization bit depths

(e.g., representing 0 presumably requires 1 bit, but may be associated with a much finer tolerance)?

Should "minimization in equation 4" refer to equation 3?

In the end, while do like the general idea of utilizing the gradient to identify how sensitive the model might be to quantization of various parameters,

there are significant clarity issues in the paper,

I am a bit uneasy about some of the compression results claimed without clearer description of the bookkeeping,

and I don't believe an approach of this kind has any significant practical relevance for saving runtime memory or compute resources.

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


Recently some interesting work on a role of prior in deep generative models has been presented.

The choice of prior may have an impact on the expressiveness of the model

[Hoffman and Johnson, 2016].

A few existing work presents methods for learning priors from data for variational autoencoders

[Goyal et al., 2017]

[Tomczak and Welling, 2017].

The work, "VAE with a VampPrior," [Tomczak and Welling, 2017] is missing in references.

The current work focuses on adversarial autoencoder (AAE) and introduces a code generator network to transform a simple prior into one that together with the generator can better fit the data distribution.

Adversarial loss is used to train the code generator network, allowing the output of the network could be any distribution.

I think the method is quite simple but interesting approach to improve AAEs without hurting the reconstruction.

The paper is well written and is easy to read.

The method is well described.

However, what is missing in this paper is an analysis of learned priors,

which help us to better understand its behavior.

The model is evaluated qualitatively only.

What about quantitative evaluation?

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


The authors consider a Neural Network where the neurons are treated as rational agents.

In this model, the neurons must pay to observe the activation of neurons upstream.

Thus, each individual neuron seeks to maximize the sum of payments it receives from other neurons minus the cost for observing the activations of other neurons (plus an external reward for success at the task).

While this is an interesting idea on its surface,

the paper suffers from many problems in clarity, motivation, and technical presentation.

It would require very major editing to be fit for publication.

The major problem with this paper is its clarity.

See detailed comments below for problems just in the introduction.

More generally, the paper is riddled with non sequiturs.

The related work section mentions Generative Adversarial Nets.

As far as I can tell, this paper has nothing to do with GANs.

The Background section introduces notation for POMDPs, never to be used again in the entirety of the paper, before launching into a paragraph about apoptosis in glial cells.

There is also a general lack of attention to detail.

For example, the entire network receives an external reward (R_t^{ex}), presumably for its performance on some task.

This reward is dispersed to the the individual agents who receive individual external rewards (R_{it}^{ex}).

It is never explained how this reward is allocated even in the authors’ own experiments.

The authors state that all units playing NOOP is an equilibrium.

While this is certainly believable/expected,

such a result would depend on the external rewards R_{it}^{ex}, the observation costs \sigma_{jit}, and the network topology.

None of this is discussed.

The authors discuss Pareto optimality without ever formally describing what multi-objective function defines this supposed Pareto boundary.

This is pervasive throughout the paper,

and is detrimental to the reader’s understanding.

While this might be lost because of the clarity problems described above,

the model itself is also never really motivated.

Why is this an interesting problem?

There are many ways to create rational incentives for neurons in a neural net.

Why is paying to observe activations the one chosen here?

The neuroscientific motivation is not very convincing to me, considering that ultimately these neurons have to hold an auction.

Is there an economic motivation?

Is it just a different way to train a NN?

Detailed Comments: “In the of NaaA” => remove “of”?

“passing its activation to the unit as cost”

=> Unclear.

What does this mean?

“performance decreases if we naively consider units as agents”

=> Performance on what?

“.. we demonstrate that the agent obeys to maximize its counterfactual return as the Nash Equilibrium“

=> Perhaps, this should be rewritten as “Agents maximize their counterfactual return in equilibrium.

“Subsequently, we present that learning counterfactual return leads the model to learning optimal topology”

=> Do you mean
“maximizing” instead of learning.

Optimal with respect to what task?

“pure-randomly” => “randomly”

“with adaptive algorithm” => “with an adaptive algorithm”

“the connection” => “connections”

“In game theory, the outcome maximizing overall reward is named Pareto optimality.”

=> This is simply incorrect.

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


The paper proposes an interesting alternative to recent approaches to learning from logged bandit feedback, and validates their contribution in a reasonable experimental comparison.

The clarity of writing can be improved

(several typos in the manuscript, notation used before defining, missing words, poorly formatted citations, etc.).

Implementing the approach using recent f-GANs is an interesting contribution and may spur follow-up work.

There are several lingering concerns about the approach (detailed below) that detract from the quality of their contributions.

[Major] In Lemma 1, L(z) is used before defining it.

Crucially, additional assumptions on L(z) are necessary (e.g. |L(z)| <= 1 for all z.

If not, a trivial counter-example is: set L(z) >> 1 for all z and Lemma 1 is violated).

It is unclear how crucially this additional assumption is required in practice

(their expts with Hamming losses clearly do not satisfy such an assumption).

[Minor] Typo: Section 3.2, first equation; the integral equals D_f(...) + 1 (not -1).

[Crucial!] Eqn10: Expected some justification on why it is fruitful to *lower-bound* the divergence term,

which contributes to an *upper-bound* on the true risk.

[Crucial!] Algorithm1: How is the condition of the while loop checked in a tractable manner?

[Minor] Typos: Initilization -> Initialization, Varitional -> Variational

[Major] Expected an additional "baseline" in the expts -- Supervised but with the neural net policy architecture

(NN approaches outperforming Supervised on LYRL dataset was baffling before realizing that Supervised is implemented using a linear CRF).

[Major] Is there any guidance for picking the new regularization hyper-parameters (or at least, a sensible range for them)?

[Minor] The derived bounds depend on M,

an a priori upper bound on the Renyi divergence between the logging policy and any new policy.

It's unclear that such a bound  can be tractably guessed

(in contrast, prior work uses an upper bound on the importance weight

-- which is simply 1/(Min action selection prob. by logging policy) ).

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


This paper provides theoretical and empirical motivations for removing the top few principle components of commonly-used word embeddings.

The paper is well-written and I enjoyed reading it.

However, it does not explain how significant this result is beyond that of (Bullinaria and Levy, 2012),

who also removed the top N dimensions when benchmarking SVD-factorized word embeddings.

From what I can see, this paper provides a more detailed explanation of the phenomenon ("why" it works),

which is supported with both theoretical results and a series of empirical analyses, as well as "updating" the benchmarks and methods from the pre-neural era.

Although this contribution is relatively incremental,

I find the depth of this work very interesting,

and I think future work could perhaps rely on these insights to create better embedding algorithms that directly enforce isotropy.

I have two concerns regarding the empirical section, which may be resolvable fairly quickly:

1) Are the embedding vectors L2 normalized before using them in each task?

This is known to significantly affect performance.

I am curious whether removing the top PCs is redundant or not given L2 normalization.

2) Most of the benchmarks used in this paper are "toy" tasks.

As Schnabel et al (2015) and Tsvetkov et al (2015) showed, there is often little correlation between success on these benchmarks and improvement of downstream NLP tasks.

I would like to measure the change in performance on a major NLP task that heavily relies on pre-trained word embeddings such as SQuAD.

Minor Comments:* The last sentence in the first paragraph ("The success comes from the geometry of the representations...") is not true;

the success stems from the ability to capture lexical similarity.

Levy and Goldberg (2014) showed that searching for the closest word vector to (king - man + woman) is equivalent to optimizing a linear combination of 3 similarity terms [+(x,king), -(x,man), +(x, woman)].

This explanation was further demonstrated by Linzen (2016) who showed that even when removing the negative term (x, man), many analogies can still be solved, i.e. by looking for a word that is similar both to "king" and to "woman".

Add to that the fact that the analogy trick works best when the vectors are L2 normalized;

if they are all on the unit sphere, what is the geometric interpretation of (king - man + woman), which is not on the unit sphere?

I suggest removing this sentence and other references to linguistic regularities from this paper,

since they are controversial at best, and distract from the main findings.

* This is also related to Bullinaria and Levy's (2012) finding that downweighting the eigenvalue matrix in SVD-based methods improves their performance.

Levy et al (2015) showed that keeping the original eigenvalues can actually degenerate SVD-based embeddings.

Perhaps there is a connection to the findings in this paper?

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


The paper proposes an adaptation of existing Graph ConvNets and evaluates this formulation on a several existing benchmarks of the graph neural network community.

In particular, a tree structured LSTM is taken and modified.

The authors describe this as adapting it to general graphs, stacking, followed by adding edge gates and residuality.

My biggest concern is novelty, as the modifications are minor.

In particular, the formulation can be seen in a different way.

As I see it, instead of adapting Tree LSTMs to arbitary graphs, it can be seen as taking the original formulation by Scarselli and replacing the RNN by a gated version, i.e. adding the known LSTM gates (input, output, forget gate).

This is a minor modification.

Adding stacking and residuality are now standard operations in deep learning,

and edge-gates have also already been introduced in the literature, as described in the paper.

A second concern is the presentation of the paper, which can be confusing at some points.

A major example is the mathematical description of the methods.

When reading the description as given, one should actually infer that Graph ConvNets and Graph RNNs are the same thing, which can be seen by the fact that equations (1) and (6) are equivalent.

Another example, after (2), the important point to raise is the difference to classical (sequential) RNNs, namely the fact that the dependence graph of the model is not a DAG anymore, which introduces cyclic dependencies.

Generally, a clear introduction of the problem is also missing.

What are the inputs,

what are the outputs,

what kind of problems should be solved?

The update equations for the hidden states are given for all models,

but how is the output calculated given the hidden states from variable numbers of nodes of an irregular graph?

The model has been evaluated on standard datasets with a performance,

which seems to be on par, or a slight edge, which could probably be due to the newly introduced residuality.

A couple of details :- the length of a graph is not defined. The size of the set of nodes might be meant.

- at the beginning of section 2.1 I do not understand the reference to word prediction and natural language processing.

RNNs are not restricted to NLP

and I think there is no need to introduce an application at this point.

- It is unclear what does the following sentence means: "ConvNets are more pruned to deep networks than RNNs"?

- What are "heterogeneous graph domains"?

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


The paper shows that several recently proposed interpretation techniques for neural network are performing similar processing and yield similar results.

The authors show that these techniques can all be seen as a product of input activations and a modified gradient, where the local derivative of the activation function at each neuron is replaced by some fixed function.

A second part of the paper looks at whether explanations are global or local.

The authors propose a metric called sensitivity-n for that purpose,

and make some observations about the optimality of some interpretation techniques with respect to this metric in the linear case.

The behavior of each explanation w.r.t. these properties is then tested on multiple DNN models tested on real-world datasets.

Results further outline the resemblance between the compared methods.

In the appendix, the last step of the proof below Eq. 7 is unclear.

As far as I can see, the variable g_i^LRP wasn’t defined,

and the use of Eq. 5 to achieve this last could be better explained.

There also seems to be some issues with the ordering i,j, where these indices alternatively describe the lower/higher layers, or the higher/lower layers.

fact fact fact fact fact fact fact evaluation evaluation request evaluation


Summary: The paper propose a method for generating adversarial examples in image recognition problems.

The Adversarial scheme is inspired in the one proposed by Goodgellow  et al 2015 (AT) that introduces small perturbations to the data in the direction that increases the error.

Such a perturbations are random (they have not structure) and lack of interpretation for a human user.

The proposal is to limit the perturbations to just three kind of global motion fields: shift, centered rotation and scale (zoom in/out).

Since the motions are small in scale,

the authors use a first-order Taylor series approximation  (as in classical optical flow).

This approximation allows to obtain close formulas for the perturbed examples; i.e. the correction factor of the Back-propagation computed derivatives w.r.t. original example.

As result, the method is computational efficient respect to the AT and the perturbations are interpretable.

Experiments demonstrate that with the MNIST database is not obtained an improvement in the error reduction but a reduction of the computational time.

However, with ta more general recognition problem conducted with the CIFAR-10 database, the use of the proposed method improves both the error and the computational time, when compared with AT and Virtual Adversarial Train.

Comments:1. The paper presents a series os typos: FILED (title), obouve, freedm, nerual,; please check carfully.

2. The Derivation of eq. (13) should be explained,

It could be said that (12) can be casted as a eigenvalue problem [for example: $ max_{\tilde v} \| \nabla_p L^T \tilde v \|^2 \;\; s.t. \| v\|=1  $] and (13) is the largest eigenvalue of $ \nabla_p L \nabla_p L^T $]

3. The improvement in the error results in the db CIFAR-10 is good enough to see merit in the proposal approach.

Maybe other perturbations with closed formula could be considered and linear combinations of them

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


The authors present a deep neural network that evaluates plate numbers.

The relevance of this problem is that there are auctions for plate numbers in Hong Kong, and predicting their value is a sensible activity in that context.

I find that the description of the applied problem is quite interesting;

in fact overall the paper is well written and very easy to follow.

There are some typos and grammatical problems (indicated below), but nothing really serious.

So, the paper is relevant and well presented.

However, I find that the proposed solution is an application of existing techniques,

so it lacks on novelty and originality.

Even though the significance of the work is apparent given the good results of the proposed neural network,

I believe that such material is more appropriate to a focused applied meeting.

However, even for that sort of setting I think the paper requires some additional work,

as some final parts of the paper have not been tested yet

(the interesting part of explanations).

Hence I don't think the submission is ready for publication at this moment.

Concerning the text, some questions/suggestions: - Abstract, line 1: I suppose "In the Chinese society..."--- are there many Chinese societies?

- The references are not properly formatted;

they should appear at (XXX YYY) but appear as XXX (YYY) in many cases, mixed with the main text.

- Footnote 1, line 2: "an exchange".

- Page 2, line 12: "prices. Among".

- Please add commas/periods at the end of equations.

- There are problems with capitalization in the references.

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


In this paper, the authors propose a novel tracking loss to convert the RPN to a tracker.

The internal structure of top layer features of RPN is exploited to treat feature points discriminatively.

In addition, the proposed compression network speeds up the tracking algorithm.

The experimental results on the VOT2016 dataset demonstrate its efficiency in tracking.

This work is the combination of Faster R-CNN (Ren et al. PAMI 2015) and tracking-by-detection framework.

The main contributions proposed in this paper are new tracking loss, network compression and results.

There are numerous concerns with this work:

1.	The new tracking loss shown in equation 2 is similar with the original Faster R-CNN loss shown in equation 1.

The only difference is to replace the regression loss with a predefined mask selection loss,

which is of little sense that the feature processing can be further fulfilled through one-layer CNN.

The empirical operation shown in figure 2 seems arbitrary and lack of theoretical explanation.

There is no insight of why doing so.

Simply showing the numbers in table 1 does not imply the necessity,

which ought to be put in the experiment sections.

2.	The network compression is engineering and lack insight as well.

To remove part of the CNN and retrain is a common strategy in the CNN compression methods [a] [b].

There is a lack of discussion with the relationship with prior arts.

3.	The organization is not clear.

Section 3.4 should be set in the experiments

and Section 3.5 should be set at the beginning of the algorithm.

The description of the network compression is not clear enough, especially the training details.

Meanwhile, the presentation is hard to follow.

There is no clear expression of how the tracker performs in practice.

4.	In addition, VOT 2016, the method should evaluate on the OTB dataset with the following trackers [c] [d].

5.	The evaluation is not fair.

In Sec 6, the authors indicate that MDNet runs at 1FPS while the proposed tracker runs at 1.6FPS.

However, MDNet is based on Matlab

and the proposed tracker is based on C++ (i.e., Caffe).

Reference:[a] On Compressing Deep Models by Low Rank and Sparse Decomposition. Yu et al. CVPR 2017.

[b] Designing Energy-Efficient Convolutional Neural Network Using Energy-Aware Pruning. Yang et al. CVPR 2017.

[c] ECO: Efficient Convolution Operators for Tracking. Danelljan et al. CVPR 2017.

[d] Multi-Task Correlation Particle Filter For Robust Object Tracking. Zhang et al. CVPR 2017.

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


This paper proposes an evolutionary algorithm for solving the variational E step in expectation-maximization algorithm for probabilistic models with binary latent variables.

This is done by (i) considering the bit-vectors of the latent states as genomes of individuals, and by (ii) defining the fitness of the individuals as the log joint distribution of the parameters and the latent space.

Pros:The paper is well written and the methodology presented is largely clear.

Cons:While the reviewer is essentially fine with the idea of the method,

the reviewer is much less convinced of the empirical study.

There is no comparison with other methods such as Monte carlo sampling.

It is not clear how computationally Evolutionary EM performs comparing to Variational EM algorithm

and there is neither experimental results nor analysis for the computational complexity of the proposed model.

The datasets used in the experiments are quite old.

The reviewer is concerned that these datasets may not be representative of real problems.

The applicability of the method is quite limited.

The proposed model is only applicable for the probabilistic models with binary latent variables,

hence it cannot be applied to more realistic complex model with real-valued latent variables.

fact fact evaluation evaluation evaluation fact evaluation fact evaluation evaluation evaluation fact fact


This paper identifies and proposes a fix for a shortcoming of the Deep Information Bottleneck approach, namely that the induced representation is not invariant to monotonic transform of the marginal distributions (as opposed to the mutual information on which it is based).

The authors address this shortcoming by applying the DIB to a transformation of the data, obtained by a copula transform.

This explicit approach is shown on synthetic experiments to preserve more information about the target, yield better reconstruction and converge faster than the baseline.

The authors further develop a sparse extension to this Deep Copula Information Bottleneck (DCIB), which yields improved representations (in terms of disentangling and sparsity) on a UCI dataset.

(significance) This is a promising idea.

This paper builds on the information theoretic perspective of representation learning,

and makes progress towards characterizing what makes for a good representation.

Invariance to transforms of the marginal distributions is clearly a useful property,

and the proposed method seems effective in this regard.

Unfortunately, I do not believe the paper is ready for publication as it stands,

as it suffers from lack of clarity and the experimentation is limited in scope.

(clarity) While Section 3.3 clearly defines the explicit form of the algorithm

(where data and labels are essentially pre-processed via a copula transform),

details regarding the “implicit form” are very scarce.

From Section 3.4, it seems as though the authors are optimizing the form of the gaussian information bottleneck I(x,t), in the hopes of recovering an encoder $f_\beta(x)$ which gaussianizes the input (thus emulating the explicit transform) ?

Could the authors clarify whether this interpretation is correct, or alternatively provide additional clarifying details ?

There are also many missing details in the experimental section:

how were the number of “active” components selected ?

Which versions of the algorithm (explicit/implicit) were used for which experiments ?

I believe explicit was used for Section 4.1, and implicit for 4.2

but again this needs to be spelled out more clearly.

I would also like to see a discussion (and perhaps experimental comparison) to standard preprocessing techniques, such as PCA-whitening.

(quality) The experiments are interesting and seem well executed.

Unfortunately, I do not think their scope (single synthetic, plus a single UCI dataset) is sufficient.

While the gap in performance is significant on the synthetic task,

this gap appears to shrink significantly when moving to the UCI dataset.

How does this method perform for more realistic data, even e.g. MNIST ?

I think it is crucial to highlight that the deficiencies of DIB matter in practice, and are not simply a theoretical consideration.

Similarly, the representation analyzed in Figure 7 is promising,

but again the authors could have targeted other common datasets for disentangling, e.g. the simple sprites dataset used in the beta-VAE paper.

I would have also liked to see a more direct and systemic validation of the claims made in the paper.

For example, the shortcomings of DIB identified in Section 3.1, 3.2 could have been verified more directly by plotting I(y,t) for various monotonic transformations of x.

A direct comparison of the explicit and implicit forms of the algorithms would also also make for a stronger paper in my opinion.

Pros:* Theoretically well motivated

* Promising results on synthetic task

* Potential for impact

Cons:* Paper suffers from lack of clarity (method and experimental section)

* Lack of ablative / introspective experiments

* Weak empirical results (small or toy datasets only).

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


This paper proposes several client-server neural network gradient update strategies aimed at reducing uplink usage while maintaining prediction performance.

The main approaches fall into two categories: structured, where low-rank/sparse updates are learned,

and sketched, where full updates are either sub-sampled or compressed before being sent to the central server.

Experiments are based on the federated averaging algorithm.

The work is valuable, but has room for improvement.

The paper is mainly an empirical comparison of several approaches, rather than from theoretically motivated algorithms.

This is not a criticism,

however, it is difficult to see the reason for including the structured low-rank experiments in the paper

(itAs a reader, I found it difficult to understand the actual procedures used.

For example, what is the difference between the random mask update and the subsampling update

(why are there no random mask experiments after figure 1, even though they performed very well)?

How is the structured update "learned"?

It would be very helpful to include algorithms.

It seems like a good strategy is to subsample, perform Hadamard rotation, then quantise.

For quantization, it appears that the HD rotation is essential for CIFAR, but less important for the reddit data.

It would be interesting to understand when HD works and why,

and perhaps make the paper more focused on this winning strategy, rather than including the low-rank algo.

If convenient, could the authors comment on a similarly motivated paper under review at iclr 2018:

VARIANCE-BASED GRADIENT COMPRESSION FOR EFFICIENT DISTRIBUTED DEEP LEARNING

pros:- good use of intuition to guide algorithm choices

- good compression with little loss of accuracy on best strategy

- good problem for FA algorithm / well motivated

cons:- some experiment choices do not appear well motivated / inclusion is not best choice

- explanations of algos / lack of 'algorithms' adds to confusion

a useful reference:  Strom, Nikko. "Scalable distributed dnn training using commodity gpu cloud computing." Sixteenth Annual Conference of the International Speech Communication Association. 2015.

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


The authors propose a generative method that can produce images along a hierarchy of specificity, i.e. both when all relevant attributes are specified, and when some are left undefined, creating a more abstract generation task.

Pros:+ The results demonstrating the method's ability to generate results for (1) abstract and (2) novel/unseen attribute descriptions, are generally convincing.

Both quantitative and qualitative results are provided.

+ The paper is fairly clear.

Cons:- It is unclear how to judge diversity qualitatively, e.g. in Fig. 4(b).

- Fig. 5 could be more convincing;

"bushy eyebrows" is a difficult attribute to judge,

and in the abstract generation when that is the only attribute specified, it is not clear how good the results are.

fact evaluation fact evaluation evaluation evaluation evaluation evaluation


Quality The method description, particularly about reference ambiguity, I found difficult to follow.

The experiments and analysis look solid,

although it would be nice to see experiments on more challenging natural image datasets.

Clarity “In general this is not possible… “ -

you are saying it is not possible to learn an encoder that recovers disentangled factors of variation?

But that seems to be one of the main goals of the paper.

It is not clear at all what is meant here or what the key problem is,

which detracts from the paper’s motivation.

What is the purpose of R_v and R_c in eq 2?

Why can these not be collapsed into the encoders N_v and N_c?

What does “different common factor” mean?

What is f_c in proof of proposition 1?

Previously f (no subscript) was referred to as a rendering engine.

T(v,c) ~ p_v and c ~ p_c are said to be independent.

But T(v,c) is explicitly defined in terms of c (equation 6).

So which is correct?

Overall the argument seems plausible -

pairs of images in which a single factor of variation changes have a reference ambiguity -

but the details are unclear.

Originality The model is very similar to Mathieu et al, although using image pairs rather than category labels directly.

The idea of weakly-supervised disentangling has also been explored in many other papers,

e.g. “Weakly-supervised Disentangling with Recurrent Transformations for 3D View Synthesis”, Yang et al.

The description of reference ambiguity seems new and potentially valuable,

but I did not find it easy to follow.

Significance Disentangling factors of variation with weak supervision is an important problem,

and this paper makes a modest advance in terms of the model and potentially in terms of the theory.

The analysis in figure 3 I found particularly interesting - illustrating that the encoder embedding dimension can have a drastic effect on the shortcut problem.

Overall I think this can be a significant contribution if the exposition can be improved.

Pros- Proposed method allows disentangling two factors of variation given a training set of image pairs with one factor of variation matching and the other non-matching.

- A challenge inherent to weakly supervised disentangling called reference ambiguity is described.

Cons- Only two factors of variation are studied,

and the datasets are fairly simple.

- The method description and the description of reference ambiguity are unclear.

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


Summary:The paper presents a novel method for answering “How many …?” questions in the VQA datasets.

Unlike previously proposed approaches, the proposed method uses an iterative sequential decision process for counting the relevant entity.

The proposed model makes discrete choices about what to count at each time step.

Another qualitative difference compared to existing approaches is that the proposed method returns bounding boxes for the counted object.

The training and evaluation of the proposed model and baselines is done on a subset of the existing VQA dataset that consists of “How many …?” questions.

The experimental results show that the proposed model outperforms the baselines discussed in the paper.

Strengths:1.	The idea of sequential counting is novel and interesting.

2.	The analysis of model performance by grouping the questions as per frequency with which the counting object appeared in the training data is insightful.

Weaknesses:1.	The proposed dataset consists of 17,714 QA pairs in the dev set, whereas only 5,000 QA pairs in the test set.

Such a 3.5:1 split of dev and test seems unconventional.

Also, the size of the test set seems pretty small given the diversity of the questions in the VQA dataset.

2.	The paper lacks quantitative comparison with existing models for counting such as with Chattopadhyay et al.

This would require the authors to report the accuracies of existing models by training and evaluating on the same subset as that used for the proposed model.

Absence of such a comparison makes it difficult to judge how well the proposed model is performing compared to existing models.

3.	The paper lacks analysis on how much of performance improvement is due to visual genome data augmentation and pre-training?

When comparing with existing models (as suggested in above), this analysis should be done, so as to identify the improvements coming from the proposed model alone.

4.	The paper does not report the variation in model performance when changing the weights of the various terms involved in the loss function (equations 15 and 16).

5.	Regarding Chattopadhyay et al. the paper says that “However, their analysis was limited to the specific subset of examples where their approach was applicable.”

It would be good it authors could elaborate on this a bit more.

6.	The relation prediction part of the vision module in the proposed model seems quite similar to the Relation Networks,

but the paper does not mention Relation Networks.

It would be good to cite the Relation Networks paper and state clearly if the motivation is drawn from Relation Networks.

7.	It is not clear what are the 6 common relationships that are being considered in equation 1.

Could authors please specify these?

8.	In equation 1, if only 6 relationships are being considered, then why does f^R map to R^7 instead of R^6?

9.	In equations 4 and 5, it is not clarified what each symbol represents, making it difficult to understand.

10.	What is R in equation 15?

Is it reward?

Overall:The paper proposes a novel and interesting idea for solving counting questions in the Visual Question Answering tasks.

However, the writing of the paper needs to be improved to make is easier to follow.

The experimental set-up – the size of the test dataset seems too small.

And lastly, the paper needs to add comparisons with existing models on the same datasets as used for the proposed model.

So, the paper seems to be not ready for the publication yet.

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


This paper proposes a recurrent neural network for visual question answering.

The recurrent neural network is equipped with a carefully designed recurrent unit called MAC (Memory, Attention and Control) cell, which encourages sequential reasoning by restraining interaction between inputs and its hidden states.

The proposed model shows the state-of-the-art performance on CLEVR and CLEVR-Humans dataset, which are standard benchmarks for visual reasoning problem.

Additional experiments with limited training data shows the data efficiency of the model, which supports its strong generalization ability.

The proposed model in this paper is designed with reasonable motivations and shows strong experimental results in terms of overall accuracy and the data efficiency.

However, an issue in the writing, usage of external component and lack of experimental justification of the design choices hinder the clear understanding of the proposed model.

An issue in the writing Overall, the paper is well written and easy to understand,

but Section 3.2.3 (The Write Unit) has contradictory statements about their implementation.

Specifically, they proposed three different ways to update the memory (simple update, self attention and memory gate),

but it is not clear which method is used in the end.

Usage of external component The proposed model uses pretrained word vectors called GloVE, which has boosted the performance on visual question answering.

This experimental setting makes fair comparison with the previous works difficult

as the pre-trained word vectors are not used for the previous works.

To isolate the strength of the proposed reasoning module, I ask to provide experiments without pretrained word vectors.

Lack of experimental justification of the design choices The proposed recurrent unit contains various design choices such as separation of three different units (control unit, read unit and memory unit), attention based input processing and different memory updates stem from different motivations.

However, these design choices are not justified well

because there is neither ablation study nor visualization of internal states.

Any analysis or empirical study on these design choices is necessary to understand the characteristics of the model.

Here, I suggest to provide few visualizations of attention weights and ablation study that could support indispensability of the design choices.

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


Instead of either optimization-based variational EM or an amortized inference scheme implemented via a neural network as in standard VAE models, this paper proposes a hybrid approach that essentially combines the two.

In particular, the VAE inference step, i.e., estimation of q(z|x), is conducted via application of a recent learning-to-learn paradigm

(Andrychowicz et al., 2016),

whereby direct gradient ascent on the ELBO criteria with respect to moments of q(z|x) is replaced with a neural network that iteratively outputs new parameter estimates using these gradients.

The resulting iterative inference framework is applied to a couple of small datasets and shown to produce both faster convergence and a better likelihood estimate.

Although probably difficult for someone to understand that is not already familiar with VAE models,

I felt that this paper was nonetheless clear and well-presented, with a fair amount of useful background information and context.

From a novelty standpoint though, the paper is not especially strong

given that it represents a fairly straightforward application of

(Andrychowicz et al., 2016).

Indeed the paper perhaps anticipates this perspective and preemptively offers that "variational inference is a qualitatively different optimization problem" than that considered in (Andrychowicz et al., 2016), and also that non-recurrent optimization models are being used for the inference task, unlike prior work.

But to me, these are rather minor differentiating factors,

since learning-to-learn is a quite general concept already,

and the exact model structure is not the key novel ingredient.

That being said, the present use for variational inference nonetheless seems like a nice application,

and the paper presents some useful insights such as Section 4.1 about approximating posterior gradients.

Beyond background and model development, the paper presents a few experiments comparing the proposed iterative inference scheme against both variational EM, and pure amortized inference as in the original, standard VAE.

While these results are enlightening,

most of the conclusions are not entirely unexpected.

For example, given that the model is directly trained with the iterative inference criteria in place,

the reconstructions from Fig. 4 seem like exactly what we would anticipate, with the last iteration producing the best result.

It would certainly seem strange if this were not the case.

And there is no demonstration of reconstruction quality relative to existing models,

which could be helpful for evaluating relative performance.

Likewise for Fig. 6,

where faster convergence over traditional first-order methods is demonstrated;

but again, these results are entirely expected

as this phenomena has already been well-documented in

(Andrychowicz et al., 2016).

In terms of Fig. 5(b) and Table 1, the proposed approach does produce significantly better values of the ELBO critera;

however, is this really an apples-to-apples comparison?

For example, does the standard VAE have the same number of parameters/degrees-of-freedom as the iterative inference model, or might eq. (4) involve fewer parameters than eq. (5) since there are fewer inputs?

Overall, I wonder whether iterative inference is better than standard inference with eq. (4), or whether the recurrent structure from eq. (5) just happens to implicitly create a better neural network architecture for the few examples under consideration.

In other words, if one plays around with the standard inference architecture a bit, perhaps similar results could be obtained.

Other minor comment:* In Fig. 5(a), it seems like the performance of the standard inference model is still improving

but the iterative inference model has mostly saturated.

* A downside of the iterative inference model not discussed in the paper is that it requires computing gradients of the objective even at test time,

whereas the standard VAE model would not.

fact fact reference fact fact evaluation evaluation evaluation evaluation reference evaluation evaluation evaluation evaluation evaluation evaluation fact evaluation evaluation fact evaluation evaluation fact evaluation fact fact evaluation fact reference fact evaluation evaluation evaluation evaluation evaluation fact fact fact


This paper tried to analyze the subspaces of the adversarial examples neighborhood.

More specifically, the authors used Local Intrinsic Dimensionality to analyze the intrinsic dimensional property of the subspaces.

The characteristics and theoretical analysis of the proposed method are discussed and explained.

This paper helps others to better understand the vulnerabilities of DNNs.