This paper focuses on the density estimation when the amount of data available for training is low.

The main idea is that a meta-learning model must be learnt, which learns to generate novel density distributions by learn to adapt a basic model on few new samples.

The paper presents two independent method.

The first method is effectively a PixelCNN combined with an attention module.

Specifically, the support set is convolved to generate two sets of feature maps, the so called "key" and the "value" feature maps.

The key feature map is used from the model to compute the attention in particular regions in the support images to generate the pixels for the new "target" image.

The value feature maps are used to copmpute the local encoding, which is used to generate the respective pixels for the new target image, taking into account also the attention values.

The second method is simpler,

and very similar to fine-tuning the basis network on the few new samples provided during training.

Despite some interesting elements,

the paper has problems.

First, the novelty is rather limited.

The first method seems to be slightly more novel,

although it is unclear whether the contribution by combining different models is significant.

The second method is too similar to fine-tuning:

although the authors claim that \mathcal{L}_inner can be any function that minimizes the total loss \mathcal{L},

in the end it is clear that the log-likelihood is used.

How is this approach (much) different from standard fine-tuning,

since the quantity P(x; \theta') is anyways unknown and cannot be "trained" to be maximized.

Besides the limited novelty,

the submission leaves several parts unclear.

First, why are the convolutional features of the support set in the first methods divided into "key" and "value" feature maps as in p_key=p[:, 0:P], p_value=p[:, P:2*P]?

Is this division arbitrary, or is there a more basic reason?

Also, is there any different between key and value?

Why not use the same feature map for computing the attention and computing eq (7)?

Also, in the first model it is suggested that an additional feature can be having a 1-of-K channel for the supporting image label:

the reason is that you might have multiple views of objects, and knowing which view contributes to the attention can help learning the density.

However, this assumes that the views are ordered, namely that the recording stage has a very particular format.

Isn't this a bit unrealistic, given the proposed setup anyways?

Regarding the second method, it is not clear why leaving this room for flexibility (by allowing L_inner to be any function) to the model is a good idea.

Isn't this effectively opening the doors to massive overfitting?

Besides, isn't the statement that the function \mathcal{L}_inner void?

At the end of the day one can also claim the same for gradient descent: you don't need to have the true gradients of the true loss, as long as the objective function obtains gradually lower and lower values?

Last, it is unclear what is the connection between the first and the second model.

Are these two independent models that solve the same problem?

Or are they connected?

Regarding the evaluation of the models, the nature of the task makes the evaluation hard:

for real data like images one cannot know the true distribution of particular support examples.

Surrogate tasks are explored, first image flipping, then likelihood estimation of Omniglot characters, then image generation.

Image flipping does not sound a very relevant task  to density estimation, given that the task is deterministic.

Perhaps, what would make more sense would be to generate a new image given that the support set has images of a particular orientation, meaning that the model must learn how to learn densities from arbitrary rotations.

Regarding Omniglot character generation, the surrogate task of computing likelihood of known samples gives a bit better,

however, this is to be expected when combining a model without attention, with an attention module.

All in all, the paper has some interesting ideas.

I encourage the authors to work more on their submission and think of a better evaluation and resubmit.

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


The authors extend the approach proposed in the  "Reverse Curriculum Learning for Reinforcement Learning" paper by adding a discriminator that gives a bonus reward to a state based on how likely it thinks the current policy is to reach the goal from said state.

The discriminator is a potentially interesting mechanism to approximate multi-step backups in sparse-reward environments.

The approach of this paper seems severely severely limited by the assumptions made by the authors, mainly assuming a deterministic environment, known goal states and the ability to sample anywhere in the state space.

Some of these assumptions may be reasonable in domains such as robotics,

but they seem very restrictive in the domains like the games considered in the paper.

Additional Comments: -The authors demonstrate some benefits of using Tendency rewards,

but made little attempt to explain why it leads to accelerated learning.

Results are pure performance results.

-The authors should probably structure the tendency reward as potential based instead of using the Gaussian kernel hack they introduce in section 4.2

- Presentation: There are several mistakes and formatting issues in References

- Assumption 2 transformations -> transitions?

-Need to add assumption 3: advance knowledge of goal state

- the use of gamma as  a scale factor in equation 2 is confusion,

it was already introduced as the discount factor ( which is default notation in RL).

It also isn't clear what the notation r_f denotes (is it the same as r^f in appendix?).

-It is nice to see that the authors compare their method with alternative approaches.

Unfortunately, the proposed method does not seem to offer many benefits.

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


This paper presents a semi-supervised extension for applying GANs to regression tasks.

The authors propose two architectures: one adds a supervised regression loss to the standard unsupervised GAN discriminator loss.

The other replaces the real/fake output of the discriminator with only a real-valued output and then applies a kernel on top of this output to predict if samples are real or fake.

The methods are evaluated on a public driving dataset,

and are shown to outperform an Improved-GAN which predicts the real-valued labels discretized into 10 classes.

This is a nice idea,

but I am not completely convinced by the experimental results.

The proposed method is compared to Improved-GAN where the real-valued labels are discretized into 10 classes.

Why 10?

How was this chosen?

The authors rightfully state that "[...] this discretization will add some unavoidable quantization error to our training" (Sec 5.2) and then again in the conclusion "determining the number of [discretization] classes for each application is non-trivial",

yet nowhere do they explore the effects of this.

Surely, this is a very important part of the evaluation?

And surely as we improve the discretization-resolution the gap between the two will close?

This needs to be evaluated.

Also, the main motivation for a GAN-based regression model is based on the paucity of labeled training data.

However, this is another place where the argument would greatly benefit from some empirical backing.

I.e., I would really at least like to see how a discriminative regression model (e.g. a pretrained convnet fine-tuned for regression) compares to the proposed technique when trained (fine-tuned) only on the (smaller) labeled data set, perhaps augmented with standard image augmentation techniques to increase the size.

Overall, I found the paper a little hard to read (especially understanding how Architecture 2 works and moreover what its motivation is)

and empirical evaluation a bit lacking.

I also found the claims of "solving" the regression task using GANs unfounded based on the experimental results presented.

In conclusion, while the technique looks promising, the novelty seems fairly low

and the evaluation can benefit from one or more additional baselines

(at the very least showing how varying the discretization resolution of the Improved-GAN affects the results, but preferably one or more discriminative baselines),

and also perhaps on one or more additional data sets to showcase the technique's generality.

Nits:Several part are quite repetitive and can benefit from a rewrite.

Particularly the last paragraphs in the Introduction.

Section 3:  notation seems inconsistent (p_z(z) vs P_z(z) directly below in Eqn 1)

The second architecture needs to be explained a little better, and motivated a little better.

Eqn 5: I think it should be 0 \geq \hat{y}, and not 0 \leq \hat{y}

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


Overall, the paper is well-written

and the proposed model is quite intuitive.

Specifically, the idea is to represent entailment as a product of continuous functions over possible worlds.

Specifically, the idea is to generate possible worlds, and compute the functions that encode entailment in those worlds.

The functions themselves are designed as tree neural networks to take advantage of logical structure.

Several different encoding benchmarks of the entailment task are designed to compare against the performance of the proposed model, using a newly created dataset.

The results seem very impressive with > 99% accuracy on tests sets.

One weakness with the paper was that it was only tested on 1 dataset.

Also, should some form of cross-validation be applied to smooth out variance in the evaluation results.

I am not sure if there are standard "shared" datasets for this task,

which would make the results much stronger.

Also how about the tradeoff, i.e., does training time significantly increase when we "imagine" more worlds.

Also, in general, a discussion on the efficiency of training the proposed model as compared to TreeNN would be helpful.

The size of the world vectors, I would believe is quite important,

so maybe a more detailed analysis on how this was chosen is important to replicate the results.

This problem, I think, is quite related to model counting.

There has been a lot of work on model counting.

a discussion on how this relates to those lines of work would be interesting.

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


The authors propose reducing the number of parameters learned by a deep network by setting up sparse connection weights in classification layers.

Numerical experiments show that such sparse networks can have similar performance to fully connected ones.

They introduce a concept of “scatter” that correlates with network performance.

Although  I found the results useful and potentially promising,

I did not find much insight in this paper.

It was not clear to me why scatter (the way it is defined in the paper) would be a useful performance proxy anywhere but the first classification layer.

Once the signals from different windows are intermixed, how do you even define the windows?

Minor Second line of Section 2.1: “lesser” -> less or fewer

fact fact fact evaluation evaluation evaluation evaluation request


This paper proposes to use Cross-Corpus training for biomedical relationship extraction from text.

- Many wording issues, like citation formats, grammar mistakes, missing words, e.g., Page 2: it as been

- The description of the methods should be improved.

For instance, why the input has only two entities?

In many biomedical sentences, there are more than two entities.

How can the proposed two models handle these cases?

- The paper just presents to train on a larger labeled corpus and test on a task with a smaller labeled set.

Why is this novel?

Nothing is novel in the deep models (CNN and TreeLSTM).

- Missing refs, like: A simple neural network module for relational reasoning, Arxiv 2017

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


The paper addresses the problem of learning the form of the activation functions in neural networks.

The authors propose to place Gaussian process (GP) priors on the functional form of each activation function (each associated with a hidden layer and unit) in the neural net.

This  somehow allows to non-parametrically infer from the data the "shape" of the activation functions needed for a specific problem.

The paper then proposes an inference framework (to approximately marginalize out all GP functions)  based on sparse GP methods that use inducing points and variational inference.

The inducing point approximation used here is very efficient since all GP functions depend on a scalar input (as any activation function!)

and therefore by just placing the inducing points in a dense grid gives a fast and accurate representation/compression of all GPs in terms of the inducing function values (denoted by U in the paper).

Of course then inference involves approximating the finite posterior over inducing function values U

and the paper make use of the standard Gaussian approximations.

In general I like the idea

and I believe that it can lead to a very useful model.

However, I have found the current paper quite preliminary and incomplete.

The authors need to address the following:

First (very important): You need to show experimentally how your method compares against regular neural nets (with specific fixed forms for their activation functions such relus etc).

At the moment in the last section you mention

"We have validated networks of Gaussian Process Neurons in a set of experiments, the details of which we submit in a subsequent publication. In those experiments, our model shows to be significantly less prone to overfitting than a traditional feed-forward network of same size, despite having more parameters."

===>  Well all this needs to be included in the same paper.

Secondly: Discuss the connection with Deep GPs (Damianou and Lawrence 2013).

Your method seems to be connected with Deep GPs

although there appear to be important differences as well.

E.g. you place GPs on the scalar activation functions in an otherwise  heavily parametrized neural network (having interconnection weights between layers) while deep GPs model the full hidden layer mapping as a single GP (which does not require interconnection weights).

Thirdly:  You need to better explain the propagation of uncertainly in section 3.2.2  and the central limit of distribution in section 3.2.1.

This is the technical part of your paper which is a non-standard approximation.

I will suggest to give a better intuition of the whole idea and move a lot of mathematical details to the appendix.

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


The paper investigates different representation learning methods to create a latent space for intrinsic goal generation in guided exploration algorithms.

The research is in principle very important and interesting.

The introduction discusses a great deal about intrinsic motivations and about goal generating algorithms.

This is really great,

just that the paper only focuses on a very small aspect of learning a state representation in an agent that has no intrinsic motivation other than trying to achieve random goals.

I think the paper (not only the Intro) could be a bit condensed to more concentrate on the actual contribution.

The contribution is that the quality of the representation and the sampling of goals is important for the exploration performance and that classical methods like ISOMap are better than Autoencoder-type methods.

Also, it is written in the Conclusions (and in other places): "[..] we propose a new intrinsically Motivated goal exploration strategy....".

This is not really true.

There is nothing new with the intrinsically motivated selection of goals here, just that they are in another space.

Also, there is no intrinsic motivation.

I also think the title is misleading.

The paper is in principle interesting.

However, I doubt that the experimental evaluations are substantial enough for profound conclusion.

Several points of critic:  - the input space was very simple in all experiments, not suitable for distinguishing between the algorithms,

for instance, ISOMap typically suffers from noise and higher dimensional manifolds, etc.

- only the ball/arrow was in the input image, not the robotic arm.

I understand this because in phase 1 the robot would not move,

but this connects to the next point:- The representation learning is only a preprocessing step requiring a magic first phase.

-> Representation is not updated during exploration

- The performance of any algorithm (except FI) in the Arm-Arrow task is really bad but without comment.

- I am skeptical about the VAE  and RFVAE results.

The difference between Gaussian sampling and the KDE is a bit alarming,

as the KL in the VAE training is supposed to match the p(z) with N(0,1).

Given the power of the encoder/decoder it should be possible to properly represent the simple embedded 2D/3D manifold and not just a very small part of it as suggested by Fig 10.

I have a hard time believing these results.

I urge you to check for any potential errors made.

If there are not mistakes then this is indeed alarming.

Questions: - Is it true that the robot always starts from same initial condition?!

Context=Emptyset.

- For ISOMap etc, you also used a 10dim embedding?

Suggestion: - The main problem seems to be that some algorithms are not representing the whole input space.

- an additional measure that quantifies the difference between true input distribution and reproduced input distribution could tier the algorithms apart and would measure more what seems to be relevant here.

One could for instance measure the KL-divergence between the true input and the sampled (reconstructed) input (using samples and KDE or the like).

- This could be evaluated on many different inputs (also those with a bit more complicated structure) without actually performing the goal finding.

- BTW: I think Fig 10 is rather illustrative and should be somehow in the main part of the paper

On the positive side, the paper provides lots of details in the Appendix.

Also, it uses many different Representation Learning algorithms and uses measures from manifold learning to access their quality.

In the related literature, in particular concerning the intrinsic motivation, I think the following papers are relevant:J. Schmidhuber, PowerPlay: training an increasingly general problem solver by continually searching for the simplest still unsolvable problem. Front. Psychol., 2013.

and G. Martius, R. Der, and N. Ay. Information driven self-organization of complex robotic behaviors. PLoS ONE, 8(5):e63400, 2013.

Typos and small details:p3 par2: for PCA you cited Bishop.

Not critical, but either cite one the original papers or maybe remove the cite altogether

p4 par-2: has multiple interests...: interests -> purposes?

p4 par-1: Outcome Space to the agent is is ...

Sec 2.2 par1: are rapidly mentioned... -> briefly

Sec 2.3 ...Outcome Space O, we can rewrite the architecture as: and then comes the algorithm.

This is a bit weird

Sec 3: par1: experimental campaign -> experiments?

p7: Context Space: the object was reset to a random position or always to the same position?

Footnote 14: superior to -> larger than

p8 par2: Exploration Ratio Ratio_expl... probably also want to add (ER) as it is later used

Sec 4: slightly underneath -> slightly below

p9 par1: unfinished sentence: It is worth noting that the....

one sentence later: RP architecture? RPE?

Fig 3: the error of the methods (except FI) are really bad.

An MSE of 1 means hardly any performance!

p11 par2: for e.g. with the SAGG..... grammar?

Plots in general: use bigger font sizes.

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


This paper proposes to adapt convnet representations to new tasks

while avoiding catastrophic forgetting by learning a per-task “controller” specifying weightings of the convolution-al filters throughout the network

while keeping the filters themselves fixed.

Pros The proposed approach is novel and broadly applicable.

By definition it maintains the exact performance on the original task,

and enables the network to transfer to new tasks using a controller with a small number of parameters (asymptotically smaller than that of the base network).

The method is tested on a number of datasets (each used as source and target) and shows good transfer learning performance on each one.

A number of different fine-tuning regimes are explored.

The paper is mostly clear and well-written

(though with a few typos that should be fixed).

Cons/Questions/Suggestions The distinction between the convolutional and fully-connected layers (called “classifiers”) in the approach description (sec 3) is somewhat arbitrary

-- after all, convolutional layers are a generalization of fully-connected layers.

(This is hinted at by the mention of fully convolutional networks.)

The method could just as easily be applied to learn a task-specific rotation of the fully-connected layer weights.

A more systematic set of experiments could compare learning the proposed weightings on the first K layers of the network (for K={0, 1, …, N}) and learning independent weights for the latter N-K layers,

but I understand this would be a rather large experimental burden.

When discussing the controller initialization (sec 4.3), it’s stated that the diagonal init works the best, and that this means one only needs to learn the diagonals to get the best results.

Is this implying that the gradients wrt off-diagonal entries of the controller weight matrix are 0 under the diagonal initialization, hence the off-diagonal entries remain zero after learning?

It’s not immediately clear to me whether this is the case

-- it could help to clarify this in the text.

If the off-diag gradients are indeed 0 under the diag init, it could also make sense to experiment with an “identity+noise” initialization of the controller matrix,

which might give the best of both worlds in terms of flexibility and inductive bias to maintain the original representation.

(Equivalently, one could treat the controller-weighted filters as a “residual” term on the original filters F with the controller weights W initialized to noise, with the final filters being F+(W\crossF) rather than just W\crossF.)

The dataset classifier (sec 4.3.4) could be learnt end-to-end by using a softmax output of the dataset classifier as the alpha weighting.

It would be interesting to see how this compares with the hard thresholding method used here.

(As an intermediate step, the performance could also be measured with the dataset classifier trained in the same way but used as a soft weighting, rather than the hard version rounding alpha to 0 or 1.)

Overall, the paper is clear and the proposed method is sensible, novel, and evaluated reasonably thoroughly.

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


This paper proposes a method of learning sparse dictionary learning by introducing new types of priors.

Specifically, they designed a novel idea of defining a metric to measure discriminative properties along with the quality of presentations.

It is also presented the power of the proposed method in comparison with the existing methods in the literature.

Overall, the paper deals with an important issue in dictionary learning and proposes a novel idea of utilizing a set of priors.

To this reviewer’s understanding, the thresholding parameter $\tau_{c}$ is specific for a class $c$ only,

thus different classes have different $\tau$ vectors.

If so, Eq. (6) for approximation of the measure $D(\cdot)$ is not clear how the similarity measure between ${\bf y}_{c,k}$ and ${\bf y}_{c1,k1}$, \ie, $\left\|{\bf y}_{c,k}^{+}\odot{\bf y}_{c1,k1}^{+}\right\|_{1}+\left\|{\bf y}_{c,k}^{+}\odot{\bf y}_{c1,k1}^{+}\right\|_{1}$ and $\left\|{\bf y}_{c,k}\odot{\bf y}_{c1,k1}\right\|_{2}^{2}$, works to approximate it.

It would be appreciated to give more detailed description on it and geometric illustration, if possible.

There are many typos and grammatical errors,

which distract from reading and understanding the manuscript.

fact fact fact evaluation fact fact evaluation request fact evaluation


This paper tackles the task of learning embeddings of multi-relational graphs using a neural network.

As much of previous work, the proposed architecture works on triples (h, r, t) wth h, t entities and r the relation type.

Despite interesting experimental results, I find that the paper carries too many imprecisions as is.

* One of the main originality of the approach is to be able for a given input triple to train by sequentially removing in turn the head h, then the tail t and finally the relation r.

(called multi-shot in the paper).

However, most (if not all) approaches learning embeddings of multi-relational graphs also create multiple examples given a triple.

And that, at least since "Learning Structured Embeddings of Knowledge Bases" by Bordes et al. 2011 that was predicting h and t (not r).

The only difference is that here it is done sequentially

while most methods sample one case each time.

Not really meaningful or at least not proved meaningful here.

* The sequential/RNN-like structure is unclear and it is hard to see how it relates to the data.

* Writing that the proposed method "unsupervised, which is distinctly different from previous works" is not true or should be rephrased.

The only difference comes from that the prediction function (softmax and not ranking for instance) and the loss used.

But none of the methods compared in the experiments use more information than GEN (the original graph).

GEN is not the only model using a softmax by the way.

* The fact of predicting indistinctly a fact or its reverse seems rather worrying to me.

Predicting that "John is_father_of Paul" or that "John is_child_of Paul" is not the same..!

How is assessed the fact that a prediction is conceptually correct?

Using types?

* The bottom part of Table 2 is surprising.

How come for the task of predicting Head, the model trained only at predicting heads (GEN(t,r => h)) performs worse than the model trained only at predicting tails (GEN(h,r => t))?

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


This paper proposes a regularization to the softmax layer, which try to make the distribution of feature representation (inputs fed to the softmax layer) more meaningful according to the Euclidean distance.

The proposed isotropic loss in equation 3 tries to equalize the squared distances from each point to the mean,

so the features are encouraged to lie close to a sphere.

Overall, the proposed method is a relatively simple tweak to softmax.

The authors show that empirically, features learned under softmax loss + isotropic regularization outperforms other features in Euclidean metric-based tasks.

My main concern with this paper is the motivation:

what are the practical scenarios in which one would want to used proposed method?

1. It is true that features learned with the pure softmax loss may not presents the ideal  similarity under the  Euclidean metric (e.g. the problem depicted in Figure 1),

because they are not trained to do so:

their purpose is just to predict the correct label.

While the proposed regularization does lead to a nicer Euclidean geometry,

there is not sufficient motivation and evidence showing this regularization improves classification accuracy.

2. In table 2, the authors seem to indicate that not using the label information in the definition of Isotropic loss is an advantage.

But this does not matter

since you already use the labels in the softmax loss.

3. I can not easily think of scenarios in which, we would like to perform KNN in the feature space (Table 3) after training a softmax layer.

In fact, Table 3 shows KNN is almost always worse than softmax in terms of classification accuracy.

4. Running kmeans or agglomerative clustering in the feature space (Table 5) *using the Euclidean metric* is again ill-posed,

because the softmax layer is not trained to do this.

If one really wants good clustering performance, one shall always try to learn a good metric, or ,

why do not you perform clustering on the softmax output (a probability vector?)

5.  The experiments on adversarial robustness and face verification seems more interesting to me,

but the tasks were not carefully explained for someone not familiar with that literature.

Perhaps for these tasks, multi-class classification is not the most correct objective, and maybe the proposed regularization can help,

but the motivations are not given.

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


This paper continues a trend of incremental improvements to Wasserstein GANs (WGAN),

where the latter were proposed in order to alleviate the difficulties encountered in training GANs.

Originally, Arjovsky et al.  [1] argued that the Wasserstein distance was superior to many others typically used for GANs.

An important feature of WGANs is the requirement for the discriminator to be 1-Lipschitz,

which [1] achieved simply by clipping the network weights.

Recently, Gulrajani et al. [2] proposed a gradient penalty "encouraging" the discriminator to be 1-Lipschitz.

However, their approach estimated continuity on points between the generated and the real samples,

and thus could fail to guarantee Lipschitz-ness at the early training stages.

The paper under review overcomes this drawback by estimating the continuity on perturbations of the real samples.

Together with various technical improvements, this leads to state-of-the-art practical performance both in terms of generated images and in semi-supervised learning.

In terms of novelty, the paper provides one core conceptual idea followed by several tweaks aimed at improving the practical performance of GANs.

The key conceptual idea is to perturb each data point twice and use a Lipschitz constant to bound the difference in the discriminator’s response on the perturbed points.

The proposed method is used in eq. (6) together with the gradient penalty from [2].

The authors found that directly perturbing the data with Gaussian noise led to inferior results

and therefore propose to perturb the hidden layers using dropout.

For supervised learning they demonstrate less overfitting for both MNIST and CIFAR 10.

They also extend their framework to the semi-supervised setting of Salismans et al 2016 and report improved image generation.

The authors do an excellent comparative job in presenting their experiments.

They compare numerous techniques (e.g., Gaussian noise, dropout) and demonstrates the applicability of the approach for a wide range of tasks.

They use several criteria to evaluate their performance (images, inception score, semi-supervised learning, overfitting, weight histogram) and compare against a wide range of competing papers.

Where the paper could perhaps be slightly improved is writing clarity.

In particular, the discussion of M and M' is vital to the point of the paper,

but could be written in a more transparent manner.

The same goes for the semi-supervised experiment details and the CIFAR-10 augmentation process.

Finally, the title seems uninformative.

Almost all progress is incremental,

and the authors modestly give credit to both [1] and [2],

but the title is neither memorable nor useful in expressing the novel idea.

[1] Martin Arjovsky, Soumith Chintala, and Leon Bottou. Wasserstein gan.

[2] Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron Courville. Improved training of wasserstein gans.

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


The authors suggest using a mixture of shared and individual rewards within a MARL environment to induce cooperation among independent agents.

They show that on their specific application this can lead to a better overall global performance than purely sharing the global signal, or using just the independent rewards.

The paper is a little too focused on the packet routing example domain and fails to deliver much in terms of a general theory of reward design for cooperative behaviours beyond showing that mixed rewards can lead to improved results in their domain.

They discuss what and how rewards,

and this could be made more formal, as well as (at the very least) some guiding principles to follow when mixing rewards.

It feels like there is a missing section between sections 2 and 3, where this methodological content could be described.

The rest of the paper has similar issues, with key intuition and concepts either missing entirely or under-represented.

The technical content often assumes that the reader is familiar with certain terms,

and it is difficult to see what meaningful conclusions can be drawn from the evaluation.

On a minor note, the use of the term cooperative in this paper could be better defined.

In game theory, cooperative games are those in which agents share rewards.

Non-cooperative (game theory) games are those where agents have general reward signals (not necessarily cooperature or adversarial).

Conventionally (yes there is existing reward design/shaping literature for MARL) people have used the same terms in MARL.

Perhaps the authors could define their approach as weakly cooperative, or emergent cooperation.

The related work could be better described.

There are existing papers on MARL and the issues with cooperation among independent learners,

and this could be referenced.

This includes reward shaping and reward potential.

I would also have expected to see brief mention of empowerment in this section too (the agent favouring states where it has the power to control outcomes in an information theoretic sense), as an underyling principle for intrinsic reward.

However, more importantly, the authors really needed to do more to synthesize this into an overall picture of what principles are at play and what ideas/methods exist that have tried to exploit some of these principles.

Detailed comments:  • [p2] the authors say "We set the meta reward signals as 1 - max(U l ).", before they define what U_l is.

• [p2] we have "As many applications in the real world can be modeled using similar methods, we expect that other fields can also benefit from this work."

This statement is too vague,

and the authors could do more to identify which application areas might benefit.

• [p3, first para] "However, the reward design studies for MARL is so limited."

Drop the word 'so'.

Also, I would argue that there have been quite a few (non-deep) discussions about reward design in MARL, cooperative, non-cooperative and competitive domains.

• [p3, sec 2.2] "This makes the diligent agents confuse about..."

should be "confused", and I would advise against anthropomorphism at least when the meaning is obscured.

• [p3, sec 3] "After having considered several other options, we finally choose the Packet Routing Domain as our experimental environments."

Not sure what useful information is being conveyed here.

• [sec 3] THe domain could be better described with intuition and formal descriptions, e.g. link utilization ratio, etc, before.

• [p6] "Importantly, the proposed blR seems to have similar capacity with dlR,"

The discussion here is all in terms of the reward acronyms with very little call on intuition or other such assistance to the reader.

• [p7] "We firstly try gR without any thinking"

The language could be better here.

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


Summary: The paper considers second-order optimization methods for training of neural networks.

In particular, the contribution of the paper is a Hessian-free method that works on blocks of parameters

(this is a user defined splitting of the parameters in blocks, e.g., parameters of each layer is one block, or parameters in several layers could constitute a block).

This results into a block-diagonal approximation to the curvature matrix, in order to improve Hessian-free convergence properties:

in the latter, a single step might require many CG steps,

so the benefit from using second-order information is not apparent.

This is mainly an experimental work,

where the authors show the merits of their approach on deep autoencoders, convolutional networks and LSTMs:

results show favourable performance compared to the original Hessian-free approach and the Adam method.

Originality: The paper is based on the works of Collobert (2004) and Le Roux et al. (2008), as well as the work of Martens:

the twist is that each layer of the neural network is considered a parameter block,

so that gradient interactions among weights in a single layer are more useful than those between weights in different layers.

This increases the separability of the problem and reduces the complexity.

Importance: Understanding the difference between first- and second-order methods for NN training is an important topic.

Using second-order methods could be considered at its infancy, compared to the wide variety of first-order methods.

Having new results on second-order methods with interesting results would definitely attract some attention at the conference.

Presentation/Clarity: The paper is well structured and well written.

The authors clearly place their work w.r.t. state of the art and previous works,

so that it is clear what is new and what is known.

Comments: 1. It is not clear why the deficiency of first-order methods on training NNs with big batches motivates us to turn into second-order methods.

Is there a reasoning for this statement?

Or is it just because second-order methods are kind-of the only other alternative we have?

2. Assuming we can perform a second-order method, like Newton's method, on a deep NN.

Since originally Newton's method was designed to find solutions that have gradient equal to zero,

and since NNs have saddle points (probably many more than local minima),

even if we could perfectly perform second-order Newton motions, there is no guarantee whether we converge to a local minimum or a saddle point.

However, since we perform Newton's method approximately in practice,

this might help escaping saddle points.

Any comment on this aspect

(I'm not aware whether this is already commented in Schraudolph 2002, where the Gauss-Newton matrix was proposed instead of the Hessian)?

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


Quality This paper demonstrates that convolutional and relational neural networks fail to solve visual relation problems by training networks on artificially generated visual relation data.

This points at important limitations of current neural network architectures where architectures depend mainly on rote memorization.

Clarity The rationale in the paper is straightforward.

I do think that breakdown of networks by testing on increasing image variability is expected given that there is no reason that networks should generalize well to parts of input space that were never encountered before.

Originality While others have pointed out limitations before,

this paper considers relational networks for the first time.

Significance  This work demonstrates failures of relational networks on relational tasks,

which is an important message.

At the same time, no new architectures are presented to address these limitations.

Pros Important message about network limitations.

Cons Straightforward testing of network performance on specific visual relation tasks.

No new theory development.

Conclusions drawn by testing on out of sample data may not be completely valid.

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


This paper introduces a simple extension to parallelize Hyperband.

Points in favor of the paper:* Addresses an important problem

Points against:* Only 5-fold speedup by parallelization with 5 x 25 workers, and worse performance in the same budget than Google Vizier (even though that treats the problem as a black box)

* Limited methodological contribution/novelty

The paper's methodological contribution is quite limited:

it amounts to a straight-forward parallelization of successive halving (SHA).

Specifically, whenever a worker frees up, do a new run on it, at the highest rung possible while making sure to not run too many runs for too high rungs.

(I am pretty sure that is the idea, even though Algorithm 1, which is supposed to give the details, appears to have a bug in Procedure get_job

-- it would always either pick the highest rung or the lowest!)

Empirically, the paper strangely does not actually evaluate a parallel version of Hyperband, but only evaluates the 5 parallel variants of SHA that Hyperband would run, each of them with all workers.

The experiments in Section 4.2 show that, using 25 workers, the best of these 5 variants obtains a 5-fold speedup over sequential Hyperband on CIFAR and an 8-fold speedup on SVHN.

I am confused: the *best* of 5 SHA variants only achieves a 5-fold speedup using 25 workers?

I.e., parallel Hyperband, which would run the 5 SHA variants in parallel, would require 125 workers but only yield a 5-fold speedup?

If I understand this correctly, I would clearly call this a negative result.

Likewise, for the large-scale experiment, a single run of Vizier actually yields as good performance as the best of the 5 SHA variants,

and it is unknown beforehand which SHA variant works best -- in this example, actually Bracket 0 (which is often the best) stagnates.

Parallel Hyperband would run the 5 SHA variants in parallel,

so its performance at a budget of 10R with a total of 500 workers can be evaluated by taking the minimum of the 5 SHA variants at a budget of 2R.

This would obtain a perplexity of above 90,

which is quite a bit worse than Vizier's result of about 82.

In general, the performance of parallel Hyperband can be computed by taking the minimum of the SHA variants and multiplying the time taken by 5;

this shows that at any time in the plot (Figure 3, left) Vizier dominates parallel Hyperband.

Again, this is apparently a negative result.

(For Figure 3, right, no results for Vizier are given yet.)

If I understand correctly, the experiment in Section 4.4 does not involve any run of Hyperband, but merely plots predictions of Qi et al.'s Paelo framework of how many models could be evaluated with a growing number of GPUs.

Therefore, all empirical results for parallel Hyperband reported in the paper appear to be negative.

This confuses me,

especially since the authors seem to take them as positive results.

Because the original Hyperband paper argued that Bayesian optimization does not parallelize as well as random search / Hyperband,

and because Hyperband has been reported to work much better than Bayesian optimization on a single node,

I would have expected clear improvements of parallel Hyperband over parallel Bayesian optimization (=Vizier in the authors' setup).

However, this is not what I see in the results.

Am I mistaken somewhere?

If not, based on these negative results the paper does not seem to quite clear the bar for ICLR.

Details, in order of appearance in the paper:- Vizier: why did the authors only use Vizier's default Bayesian optimization algorithm?

The Vizier paper by Golovin et al (2017) states that for large budgets other optimizers often perform better, and the budget in the large scale experiments is as high as 5000 function evaluations.

Also, isn't there an automatic choice built into Vizier to pick the optimizer expected to be best?

I think using a suboptimal version of Vizier would be a problem for the experimental setup.

- Algorithm 1: this needs some improvement; in particular fixing the bug I mentioned above.

- Section 3.1: Li et al (2017) do not analyze any algorithm theoretically.

They also do not discuss finite vs. infinite horizon.

I believe the authors meant Li et al's arXiv paper (2016) in both of these cases.

- Section 3.1, point 2: this is unclear to me, even though I know Hyperband very well.

Can you please make this clearer?

- "A complete theoretical treatment of asynchronous SHA is out of the scope of this paper"

-> is some theoretical treatment in scope?

- Section 4.1: It seems very useful to already recommend configurations in each rung of Hyperband,

and I am surprised that the methods section does not mention this.

From the text in this experiments section, it feels a little like that was always part of Hyperband;

I didn't think it was,

so I checked the original papers and blog posts,

and both the ICLR 2017 and the arXiv 2016 paper state "In fact, the first result returned by HYPERBAND after using a budget of 5R is often competitive with results returned by other searchers after using 50R."

and Kevin Jamieson's blog post on Hyperband (https://people.eecs.berkeley.edu/~kjamieson/hyperband.html) explicitly states: "While random and the Bayesian Optimization algorithms output their first recommendation after max_iter iterations, Hyperband does not output anything until about max_iter(logeta(max_iter)+1) iterations [...]"

Therefore, recommending after each rung seems to be a contribution of this paper,

and I think it would be nice to read about this in the methods section.

- Experiment 1 (SVM) used dataset size as a budget, which is what Fabolas ("Fast Bayesian optimization on large datasets") is designed for according to Klein et al (2017).

On the other hand, Experiments (2) and (3) used the number of epochs as a budget, and Fabolas is not designed for that

(one would want to use a different kernel, for epochs, e.g., like Freeze-Thaw Bayesian optimization (FTBO) by Swersky et al (2014), instead of a kernel made for dataset sizes).

Therefore, it is not surprising that Fabolas does not work as well in those cases.

The case of number of epochs as a budget would be the domain of FTBO.

I know that there is no reference implementation of FTBO,

so I am not asking for a comparison, but the comparison against Fabolas is misleading for Experiments (2) and (3).

This doesn't really change anything for the paper:

the authors could still make the case that Fabolas hasn't been designed for this case and that (to the best of my knowledge) there simply isn't an implementation of a BO algorithm that is.

Fabolas is arguably the closest thing,

so the results could still be reported, just not as an apples-to-apples comparison; probably best as "Fabolas-like, with dataset size kernel" in the figure.

The justification to not compare against Fabolas in the parallel regime is clearly valid.

- A clarification question: Section 4.4 does not report on any runs of actual neural networks, does it?

And not on any runs of Hyperband, correct?

Do I understand the reasoning correctly as pointing out that standard parallelization across multiple GPUs is not great, and that thus, in combination with parallel Hyperband, runs should be done mostly on one GPU only?

How does this relate to the results in the cited paper "Accurate, Large-batch SGD: Training ImageNet in 1 Hour" (https://arxiv.org/abs/1706.02677)?

Quoting from its abstract: "Using commodity hardware, our implementation achieves ∼ 90% scaling efficiency when moving from 8 to 256 GPUs."

That seems like a very good utilization of parallel computing power?

- There is no conclusion / future work.

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


This paper introduces a new toolbox for deep neural networks learning and evaluation.

The central idea is to include time in the processing of all the units in the network.

For this, the authors propose a paradigm switch: form layerwise-sequential networks, where at every time frame the network is evaluated by updating each layer – from bottom to top – sequentially; to layerwise-parallel networks, where all the neurons are updated in parallel.

The new paradigm implies that the layer update is achieved by using the stored previous state and the corresponding previous state of the previous layer.

This has three consequences.

First, every layer now use memory,

a condition that already applies for RNNs in layerwise-sequential networks.

Second, in order to have a consistent output, the information has to flow in the network for a number of time frames equal to the number of layers.

In Neuroscience, this concept is known as reaction time.

Third, since the network is not synchronized in terms of the information that is processed in a specific time frame, there are discrepancies w.r.t. the layerwise-sequential networks computation: all the techniques used to train deep NNs have to be reconsidered.

Overall, the concept is interesting and timely especially for the rising field of spiking neural networks or for large and distributed architectures.

The paper, however, should probably provide more examples and results in terms of architectures that can been implemented with the toolbox in comparison with other toolboxes.

The paper presents a single example in which either the accuracy and the training time are not reported.

While I understand that the main result of this work is the toolbox itself, more examples and results would improve the clarity and the implications for such paradigm switch.

Another concern comes from the choice to use Theano as back-end,

since it's known that it is going to be discontinued.

Finally I suggest to improve the clarity and description of Figure 2,

which is messy and confusing especially if printed in B&W.

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


The authors propose WAGE, which discretized weights, activations, gradients, and errors at both training and testing time.

By quantization and shifting, SGD training without momentum, and removing the softmax at output layer as well, the model managed to remove all cumbersome computations from every aspect of the model,

thus eliminating the need for a floating point unit completely.

Moreover, by keeping up to 8-bit accuracy, the model performs even better than previously proposed models.

I am eager to see a hardware realization for this method because of its promising results.

The model makes a unified discretization scheme for 4 different kinds of components,

and the accuracy for each of the kind becomes independently adjustable.

This makes the method quite flexible and has the potential to extend to more complicated networks, such as attention or memory.

One caveat is that there seem to be some conflictions in the results shown in Table 1, especially ImageNet.

Given the number of bits each of the WAGE components asked for, a 28.5% top 5 error rate seems even lower than XNOR.

I suspect it is due to the fact that gradients and errors need higher accuracy for real-valued input,

but if that is the case, accuracies on SVHN and CIFAR-10 should also reflect that.

Or, maybe it is due to hyperparameter setting or insufficient training time?

Also, dropout seems not conflicting with the discretization.

If there are no other reasons, it would make sense to preserve the dropout in the network as well.

In general, the paper was writ ten in good quality and in detail,

I would recommend a clear accept.

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


Adversarial example is studied on one synthetic data.

A neural networks classifier is trained on this synthetic data.

Average distances and norms of errorneous perturbations are computed.

It is observed that small perturbation (chosen in a right direction) is sufficient to cause misclassification.

CONS: The writing is bad and hard to follow, with typos:

for example what is a period just before section 3.1 for?

Another example is "Red lines indicate the range of needed for perfect classification", which does not make sense.

Yet another example is the period at the end of Proposition 4.1.

Another example is "One counter-intuitive property of adversarial examples is it that nearly ".

It looks as if the paper was written in a hurry, and it shows in the writing.

At the beginning of Section 3, Figure 1 is discussed.

It points out that there exists adversarial directions that are very bad.

But I don't see how it is relevant to adversarial examples.

If one was interested in studying adversarial examples, then one would have done the following.

Under the setting of Figure 1, pick a test data randomly from the distribution (and one of the classes), and find an adversarial direction

I do not see how Section 3.1 fits in with other parts of the paper.

Is it related to any experiment?

Why it defining a manifold attack?

Putting a "conjecture" on a paper has to be accompanied by the depth of the insight that brought the conjecture.

Having an unjustified conjecture 5.1 would poison the field of adversarial examples,

and it must be removed.

This paper is a list of experiments and observations, that are not coherent and does not give much insight into the topics of "adversarial examples".

The only main messages are that on ONE synthetic dataset, random perturbation does not cause misclassification and targeted classification can cause misclassification.

And, expected loss is good while worst-case loss is bad.

This, in my opinion, is not enough to be published at a conference.

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


The paper proposes to augment (traditional) text-based sentence generation/dialogue approaches by incorporating visual information.

The idea is that associating visual information with input text, and using that associated visual information as additional input will produce better output text than using only the original input text.

The basic idea is to collect a bunch of data consisting of both text and associated images or video.

Here, this was done using Japanese news programs.

The text+image/video is used to train a model that requires both as input and that encodes both as context vectors, which are then combined and decoded into output text.

Next, the image inputs are eliminated, with the encoded image context vector being instead associatively predicted directly from the encoded text context vector (why not also use the input text to help predict the visual context?), which is still obtained from the text input, as before.

The result is a model that can make use of the text-visual associations without needing visual stimuli.

This is a nice idea.

Actually, based on the brief discussion in Section 2.2.2, it occurs to me that the model  might not really be learning visual context vectors associatively, or, that this doesn't really have meaning in some sense.

Does it make sense to say that what it is really doing is just learning to associate other concepts/words with the input text, and that it is using the augmenting visual information in the training data to provide those associations?

Is this worth talking about?

Unfortunately, while the idea has merit, and I'd like to see it pursued,

the paper suffers from a fatal lack of validation/evaluation,

which is very curious, given the amount of data that was collected, the fact that the authors have both a training and a test set, and that there are several natural ways such an evaluation might be performed.

The two examples of Fig 3 and the additional four examples in the appendix are nice for demonstrating some specific successes or weaknesses of the model,

but they are in no way sufficient for evaluation of the system, to demonstrate its accuracy or value in general.

Perhaps the most obvious thing that should be done is to report the model's accuracy for reproducing the news dialogue, that is, how accurately is the next sentence predicted by the baseline and ACM models over the training instances and over the test data?

How does this compare with other state-of-the-art models for dialogue generation trained on this data (perhaps trained only on the textual part of the data in some cases)?

Second, some measure of accuracy for recall of the associative image context vector should be reported; for example, on average, how close (cosine similarity or some other appropriate measure) is the associatively recalled image context vector to the target image context vector?

On average?

Best case?

Worst case?

How often is this associative vector closer to a confounding image vector than an appropriate one?

A third natural kind of validation would be some form of study employing human subjects to test it's quality as a generator of dialogue.

One thing to note, the example of learning to associate the snowy image with the text about university entrance exams demonstrates that the model is memorizing rather than generalizing.

In general, this is a false association

(that is, in general, there is no reason that snow should be associated with exams on the 14th and 15th—the month is not mentioned, which might justify such an association.)

Another thought: did you try not retraining the decoder and attention mechanisms for step 3?

In theory, if step 2 is successful, the retraining should not be necessary.

To the extent that it is necessary, step 2 has failed to accurately predict visual context from text.

This seems like an interesting avenue to explore (and is obviously related to the second type of validation suggested above).

Also, in addition to the baseline model, it seems like it would be good to compare a model that uses actual visual input and the model of step 1 against the model of step 3 (possibly bot retrained and not retrained) to see the effect on the outputs generated—how well do each of these do at predicting the next sentence on both training and test sets?

Other concerns:1. The paper is too long by almost a page in main content.

2. The paper exhibits significant English grammar and usage issues

and should be carefully proofed by a native speaker.

3. There are lots of undefined variables in the Eqs. (s, W_s, W_c, b_s, e_t,i, etc.)

Given the context and associated discussion, it is almost possible to sort out what all of them mean,

but brief careful definitions should be given for clarity.

4. Using news broadcasts as a substitute for true dialogue data seems kind of problematic,

though I see why it was done.

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


A DeepRL algorithm is presented that represents distributions over Q values, as applied to DDPG, and in conjunction with distributed evaluation across multiple actors, prioritized experience replay, and N-step look-aheads.

The algorithm is called Distributed Distributional Deep Deterministic Policy Gradient algorithm, D4PG.

SOTA results are generated for a number of challenging continuous domain learning problems, as compared to benchmarks that include DDPG and PPO, in terms of wall-clock time, and also (most often) in terms of sample efficiency.

pros/cons + the paper provides a thorough investigation of the distributional approach, as applied to difficult continuous action problems, and in conjunction with a set of other improvements (with ablation tests)

- the story is a bit mixed in terms of the benefits, as compared to the non-distributional approach, D3PG

- it is not clear which of the baselines are covered in detail in the cited paper:

"Anonymous. Distributed prioritized experience replay. In submission, 2017.",

i.e., should readers assume that D3PG already exists and is attributable to this other submission?

Overall, I believe that the community will find this to be interesting work.

Is a video of the results available?

It seems that the distributional model often does not make much of a difference, as compared to D3PG non-prioritized.

However, sometimes it does make a big difference, i.e., 3D parkour; acrobot.

Do the examples where it yields the largest payoff share a particular characteristic?

The benefit of the distributional models is quite different between the 1-step and 5-step versions.

Any ideas why?

Occasionally, D4PG with N=1 fails very badly, e.g., fish, manipulator (bring ball), swimmer.

Why would that be?

Shouldn't it do at least as well as D3PG in general?

How many atoms are used for the categorical representation?

As many as [Bellemare et al.], i.e., 51 ?

How much "resolution" is necessary here in order to gain most of the benefits of the distributional representation?

As far as I understand, V_min and V_max are not the global values, but are specific to the current distribution.

Hence the need for the projection.

Is that correct?

Would increasing the exploration noise result in a larger benefit for the distributional approach?

Figure 2: DDPG performs suprisingly poorly in most examples.

Any comments on this, or is DDPG best avoided in normal circumstances for continuous problems? :-)

Is the humanoid stand so easy because of large (or unlimited) torque limits?

The wall-clock times are for a cluster with K=32 cores for Figure 1?

"we utilize a network architecture as specified in Figure 1 which processes the terrain info in order to reduce its dimensionality"

Figure 1 provides no information about the reduced dimensionality of the terrain representation,

unless I am somehow failing to see this.

"the full critic architecture is completed by attaching a critic head as defined in Section A"

I could find no further documenation in the paper with regard to the "head" or a separate critic for the "head".

It is not clear to me why multiple critics are needed.

Do you have an intuition as to why prioritized replay might be reducing performance in many cases?

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


1) Summary This paper proposes a flow-based neural network architecture and adversarial training for multi-step video prediction.

The neural network in charge of predicting the next frame in a video implicitly generates flow that is used to transform the previously observed frame into the next.

Additionally, this paper proposes a new quantitative evaluation criteria based on the observed flow in the prediction in comparison to the groundtruth.

Experiments are performed on a new robot arm dataset proposed in the paper where they outperform the used baselines.

2) Pros:+ New quantitative evaluation criteria based on motion accuracy.

+ New dataset for robot arm pushing objects.

3) Cons:Overall architectural prediction network differences with baseline are unclear:

The differences between the proposed prediction network and [1] seem very minimal.

In Figure 3, it is mentioned that the network uses a U-Net with recurrent connections.

This seems like a very minimal change in the overall architecture proposed.

Additionally, there is a paragraph of “architecture improvements” which also are minimal changes.

Based on the title of section 3, it seems that there is a novelty on the “prediction with flow” part of this method.

If this is a fact, there is no equation describing how this flow is computed.

However, if this “flow” is computed the same way [1]  does it, then the title is misleading.

Adversarial training objective alone is not new as claimed by the authors:

The adversarial objective used in this paper is not new.

Works such as [2,3] have used this objective function for single step and multi-step frame prediction training, respectively.

If the authors refer to the objective being new in the sense of using it with an action conditioned video prediction network, then this is again an extremely minimal contribution.

Essentially, the authors just took the previously used objective function and used it with a different network.

If the authors feel otherwise, please comment on why this is the case.

Incomplete experiments:The authors only show experiments on videos containing objects that have already been seen,

but no experiments with objects never seen before.

The missing experiment concerns me in the sense that the network could just be memorizing previously seen objects.

Additionally, the authors present evaluation based on PSNR and SSIM on the overall predicted video, but not in a per-step paradigm.

However, the authors show this per-step evaluation in the Amazon Mechanical Turk, and predicted object position evaluations.

Unclear evaluation:The way the Amazon Mechanical Turk experiments are performed are unclear and/or not suited for the task at hand.

Based on the explanation of how these experiments are performed, the authors show individual images to mechanical turkers.

If we are evaluating the video prediction task for having real or fake looking videos, the turkers need to observe the full video and judge based on that.

If we are just showing images, then they are evaluating image synthesis, which do not necessarily contain the desired properties in videos such as temporal coherence.

Additional comments:The paper needs a considerable amount of polishing.

4) Conclusion:This paper seems to contain very minimal changes in comparison to the baseline by [1].

The adversarial objective is not novel as mentioned by the authors and has been used in [2,3].

Evaluation is unclear and incomplete.

References:[1] Chelsea Finn, Ian Goodfellow, and Sergey Levine. Unsupervised learning for physical interaction through video prediction. In NIPS, 2016.

[2] M. Mathieu, C. Couprie, and Y. LeCun. Deep multi-scale video prediction beyond mean square error. In ICLR, 2016.

[3] Ruben Villegas, Jimei Yang, Seunghoon Hong, Xunyu Lin, Honglak Lee. Decomposing Motion and Content for Natural Video Sequence Prediction. In ICLR, 2017

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


The paper basically propose keep using the typical data-augmentation transformations done during training also in evaluation time, to prevent adversarial attacks.

In the paper they analyze only 2 random resizing and random padding,

but I suppose others like random contrast, random relighting, random colorization, ... could be applicable.

\n\nSome of the pros of the proposed tricks is that it doesn't require re-training existing models,

although as the authors pointed out re-training for adversarial images is necessary to obtain good results.

\n\n\nTypically images have different sizes

, however in the Dataset are described as having 299x299x3 size,

are all the test images resized before hand?

How would this method work with variable size images?

\n\nThe proposed defense requires increasing the size of the input images,

have you analyzed the impact in performance?

Also it would be good to know how robust is the method for smaller sizes.

\n\nSection 4.6.2 seems to indicate that 1 pixel padding or just resizing 1 pixel is enough to get most of the benefit,

please provide an analysis of how results improve as the padding or size increase.

\n\nIn section 5 for the challenge authors used a lot more evaluations per image,

could you provide how much extra computation is needed for that model?

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


This submission proposes a new seq2sel solution by adopting two new techniques, a sequence-to-set model and column attention mechanism.

They show performance improve over existing studies on WikiSQL dataset.

While the paper is written clearly,

the contributions of the work heavily depends on the WikiSQL dataset.

It is not sure if the approach is generally applicable to other sequence-to-sql workloads.

Detailed comments are listed below: 1. WikiSQL dataset contains only a small class of SQL queries, with aggregation over single table and various filtering conditions.

It does not involve any complex operator in relational database system, e.g., join and groupby.

Due to its simple structure, the problem of sequence-to-sql translation over WikiSQL is actually simplified as a parameter selection problem for a fixed template.

This greatly limits the generalization of approaches only applicable to WikiSQL.

The authors are encouraged to explore other datasets available in the literature.

2. The "order-matters" motivation is not very convincing.

It is straightforward to employ a global ordering approach to rank the columns and filtering conditions based on certain rules, e.g., alphabetical order.

That could ensure the orders in the SQL results are always consistent.

3. The experiments do not fully verify how the approaches bring performance improvements.

In the current version, the authors only report superficial accuracy results on final outcomes, without any deep investigation into why and how their approach works.

For instance, they could verify how much accuracy improvement is due to the insensitivity to order in filtering expressions.

4. They do not compare against state-of-the-art solution on column and expression selection.

While their attention mechanism over the columns could bring performance improvement,

they should have included experiments over existing solutions designed for similar purpose.

In (Yin, et al., IJCAI 2016), for example, representations over the columns are learned to generate better column selection.

As a conclusion, I find the submission contains certain interesting ideas but lacks serious research investigations.

The quality of the paper could be much enhanced, if the authors deepen their studies on this direction.

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


In this work, discrete-weight NNs are trained using the variational Bayesian framework, achieving similar results to other state-of-the-art models.

Weights use 3 bits on the first layer and are ternary on the remaining layers.

- Pros: The paper is well-written and connections with the literature properly established.

The approach to training discrete-weights NNs, which is variational inference, is more principled than previous works (but see below).

- Cons: The authors depart from the original motivation when the central limit theorem is invoked.

Once we approximate the activations with Gaussians, do we have any guarantee that the new approximate lower bound is actually a lower bound?

This is not discussed.

If it is not a lower bound, what is the rationale behind maximizing it?

This seems to place this work very close to previous works, and not in the "more principled" regime the authors claim to seek.

The likelihood weighting seems hacky.

The authors claim "there are usually many more NN weights than there are data samples".

If that is the case, then it seems that the prior dominating is indeed the desired outcome.

A different, more flat prior (or parameter sharing), can be used,

but the described reweighting seems to be actually breaking a good property of Bayesian inference,

which is defecting to the prior when evidence is lacking.

In terms of performance (Table 1), the proposed method seems to be on par with existing ones.

It is unclear then what the advantage of this proposal is.

Sparsity figures are provided for the current approach,

but those are not contrasted with existing approaches.

Speedup is claimed with respect to an NN with real weights, but not with respect existing NNs with binary weights,

which is the appropriate baseline.

- Minor comments: Page 3: Subscript t and variable t is used for the targets,

but I can't find where it is defined.

Only the names of the datasets used in the experiments are given,

but they are not described, or even better, shown in pictures (maybe in a supplementary).

The title of the paper says "discrete-valued NNs".

The weights are discrete, but the activations and outputs are continuous,

so I find it confusing.

As a contrast, I would be less surprised to hear a sigmoid belief network called a "discrete-valued NN", even though its weights are continuous.

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


This paper explores learning dynamic filters for CNNs.

The filters are generated by using the features of an autoencoder on the input image, and linearly combining a set of base filters for each layer.

This addresses an interesting problem which has been looked at a lot before, but with some small new parts.

There is a lot of prior work in this area

that should be cited in the area of dynamic filters and steerable filters.

There are also parallels to ladder networks that should be highlighted.

The results indicate improvement over baselines,

however baselines are not strong baselines.

A key question is what happens when this method is combined with VGG11 which the authors train as a baseline?

What is the effect of the reconstruction loss?

Can it be removed?

There should be some ablation study here.

Figure 5 is unclear what is being displayed,

there are no labels.

Overall I would advise the authors to address these questions and suggest this as a paper suitable for a workshop submission.

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


This paper proposes a simple modification to the standard alternating stochastic gradient method for GAN training, which stabilizes training, by adding a prediction step.

This is a clever and useful idea,

and the paper is very well written.

The proposed method is very clearly motivated, both intuitively and mathematically,

and the authors also provide theoretical guarantees on its convergence behavior.

I particularly liked the analogy with the damped harmonic oscillator.

The experiments are well designed and provide clear evidence in favor of the usefulness of the proposed technique.

I believe that the method proposed in this paper will have a significant impact in the area of GAN training.

I have only one minor question: in the prediction step, why not use a step size, say $\bar{u}_k+1 = u_{k+1} + \gamma_k (u_{k+1} − u_k)$, such that the "amount of predition" may be adjusted?

fact evaluation evaluation evaluation fact evaluation evaluation evaluation non-arg


Authors provide an interesting loss function approach for clustering using a deep neural network.

They optimize Kuiper-based nonparametric loss and apply the approach on a large social network data-set.

However, the details of the deep learning approach are not well described.

Some specific comments are given below.

1.Further details on use of 10-fold cross validation need to be discussed including over-fitting aspect.

2. Details on deep learning, number of hidden layers, number of hidden units, activation functions, weight adjustment details on each learning methods should be included.

3. Conclusion section is very brief

and can be expanded by including a discussion on results comparison and  over fitting aspects in cross validation.

Use of Kuiper-based nonparametric loss should also be justified as there are other loss functions can be used under these settings.

fact fact evaluation non-arg request request evaluation request request


This paper investigates meta-learning strategy for automated architecture search in the context of RNN.

To constraint the architecture search space, authors propose a DSL that specifies the RNN recurrent operations.

This DSL allows to explore RNN architectures using either random search or a reinforcement-learning strategy.

Candidate architectures are ranked using a TreeLSTM that tries to predict the architecture performances.

The top-k architectures are then evaluated by fully training them on a given task.

Authors evaluate their approach on  PTB/Wikitext 2 language modeling and Multi30k/IWSLT'16  machine translation.

In both experiments, authors show that their approach obtains competitive results and can sometime outperforms RNN cells such as GRU/LSTM.

In the PTB experiment, their architecture however underperforms other LSTM variant in the literatures.

- Quality/Clarity The paper is overall well written and pleasant to read.

Few details can be clarified.

In particular how did you initialize the weight and bias for both the LSTM/GRU baselines and the found architectures?

Is there other works leveraging RNN that report results on the Multi30k/IWSLT datasets?

You state in paragraph 3.2 that human experts can inject the previous best known architecture when training the ranking networks.

Did you use this in the experiments?

If yes, what was the impact of this online learning strategy on the final results?

- Originality The idea of using DSL + ranking for architecture search seems novel.

- Significance Automated architecture search is a promising way to design new networks.

However, it is not clear why the proposed approach is not able to outperforms other LSTM-based architectures on the PTB task.

Could the problem arise from the DSL that constraint too much the search space ?

It would be nice to have other tasks that are commonly used as benchmark for RNN to see where this approach stand.

In addition, authors propose both a DSL, a random and RL generator and a ranking function.

It would be nice to disentangle the contributions of the different components.

In particular, did the authors compare the random search vs the RL based generator or the performances of the RL-based generator when the ranking network is not used?

Although authors do show that they outperform NAScell in one setting,

it would be nice to have an extended evaluation (using character level PTB for instance).

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


This writeup describes an application of recurrent autoencoder to analysis of multidimensional time series.

The quality of writing, experimentation and scholarship is clearly below than what is expected from a scientific article.

The method is explained in a very unclear way,

there is no mention of any related work.

I would encourage the authors to take a look at other ICLR submissions and see how rigorously written they are, how they position the reported research among comparable works.


The paper proposes to use a regularizer for tensor completion problems that can be written in a similar fashion as the variational factorization formulation of the trace norm aka nuclear norm for matrices.

The paper introduces the regularizer

with the nice argument that the gradient of the L3 norm to the power of 3rd will be easy to compute,

but if we were raising the L2 norm to the 3rd power it would not be the case.

They mention that their argument can generalize from D=3 to higher order tensors.

Authors mention the paper by Friedland and Lim that introduces this norm and provides first theoretical results on it.

Authors develop on the tensor equivalent of the matrix max norm

which is built with the motivation of bringing robustness to heavy nodes in the graph (very popular content).

This is again straightforward on the technical side.

Empirical results are fine but do not show huge improvements compared to baselines

so I do not think this is a strong argument for accepting the paper.

On the scalability, authors do not show that their approach is better suited than baselines.

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


The paper suggests an importance sampling based Coreset construction for Support Vector Machines (SVM).

To understand the results, we need to understand Coreset and importance sampling:

Coreset: In the context of SVMs, a Coreset is a (weighted) subset of given dataset such that for any linear separator, the cost of the separator with respect to the given dataset X is approximately (there is an error parameter \eps) the same as the cost with respect to the weighted subset.

The main idea is that if one can find a small coreset, then finding the optimal separator (maximum margin etc.) over the coreset might be sufficient.

Since the computation is done over a small subset of points, one hopes to gain in terms of the running time.

Importance sampling: This is based on the theory developed in Feldman and Langberg, 2011 (and some of the previous works such as Langberg and Schulman 2010, the reference of which is missing).

The idea is to define a quantity called sensitivity of a data-point that captures how important this datapoint is with respect to contributing to the cost function.

Then a subset of datapoint are sampled based on the sensitivity and the sampled data point is given weight proportional to inverse of the sampling probability.

As per the theory developed in these past works, sampling a subset of size proportional to the sum of sensitivities gives a coreset for the given problem.

So, the main contribution of the paper is to do all the sensitivity calculations with respect to SVM problem and then use the importance sampling theory to obtain bounds on the coreset size.

One interesting point of this construction is that Coreset construction involves solving the SVM problem on the given dataset which may seem like beating the purpose.

However, the authors note that one only needs to compute the Coreset of small batches of the given dataset and then use standard procedures (available in streaming literature) to combine the Coresets into a single Coreset.

This should give significant running time benefits.

The paper also compares the results against the simple procedure where a small uniform sample from the dataset is used for computation.

Evaluation: Significance: Coresets give significant running time benefits when working with very big datasets.

Coreset construction in the context of SVMs is a relevant problem and should be considered significant.

Clarity: The paper is reasonably well-written.

The problem has been well motivated and all the relevant issues point out for the reader.

The theoretical results are clearly stated as lemmas a theorems that one can follow without looking at proofs.

Originality: The paper uses previously developed theory of importance sampling.

However, the sensitivity calculations in the SVM context is new as per my knowledge.

It is nice to know the bounds given in the paper and to understand the theoretical conditions under which we can obtain running time benefits using corsets.

Quality: The paper gives nice theoretical bounds in the context of SVMs.

One aspect in which the paper is lacking is the empirical analysis.

The paper compares the Coreset construction with simple uniform sampling.

Since Coreset construction is being sold as a fast alternative to previous methods for training SVMs,

it would have been nice to see the running time and cost comparison with other training methods that have been discussed in section 2.

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


Quality: Although the research problem is an interesting direction

the quality of the work is not of a high standard.

My main conservation is that the idea of perturbation in semantic latent space has not been described in an explicit way.

How different it will be compared to a perturbation in an input space?

Clarity: The use of the term "adversarial" is not quite clear in the context

as in many of those example classification problems the perturbation completely changes the class label (e.g. from "church" to "tower" or vice-versa)

Originality: The generation of adversarial examples in black-box classifiers has been looked in GAN literature as well and gradient based perturbations are studied too.

What is the main benefit of the proposed mechanism compared to the existing ones?

Significance: The research problem is indeed a significant one

as it is very important to understand the robustness of the modern machine learning methods by exposing them to adversarial scenarios where they might fail.

pros: (a) An interesting problem to evaluate the robustness of black-box classifier systems

(b) generating adversarial examples for image classification as well as text analysis.

(c) exploiting the recent developments in GAN literature to build the framework forge generating adversarial examples.

cons:(a) The proposed search algorithm in the semantic latent space could be computationally intensive.

any remedy for this problem?

(b) Searching in the latent space z could be strongly dependent on the matching inverter $I_\gamma(.)$.

any comment on this?

(c) The application of the search algorithm in case of imbalanced classes could be something that require further investigation.

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


This work attempts to improve the global consistency of samples generated by generative adversarial networks by replacing the discriminator with an autoregressive model in an encoded feature space.

The log likelihood of the classification model is then replaced with the log likelihood of the feature space autoregressive model.

It's not clear what can be said with respect to the convergence properties of this class of models,

and this is not discussed.

The method is quite similar in spirit to Denoising Feature Matching of Warde-Farley & Bengio (2017),

as both estimate a density model in feature space -- this method via a constrained autoregressive model and DFM via an estimator of the score function,

although DFM was used in conjunction with the standard criterion whereas this method replaces it.

This is certainly worth mentioning and discussing.

In particular the section in Warde-Farley & Bengio regarding the feature space transformation of the data density seems quite relevant in this work.

Unfortunately the only quantitative measurements reporter are Inception scores,

which is known to be a poor measure

(and the scores presented are not particularly high, either);

Frechet Inception distance or log likelihood estimates via AIS on some dataset would be more convincing.

On the plus side, the authors report an average over Inception scores for multiple runs.

On the other hand, it sounds as though the stopping criterion was still qualitative.

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


This work introduces a particular parametrization of a stochastic policy (a uniform mixture of deterministic policies).

They find this parametrization, when trained with stochastic value gradient outperforms DDPG on several OpenAI gym benchmarks.

This paper unfortunately misses many significant pieces of prior work training stochastic policies.

The most relevant is [1] which should definitely be cited.

The algorithm here can be seen as SVG(0) with a particular parametrization of the policy.

However, numerous other works have examined stochastic policies including [2] (A3C which also used the Torcs environment) and [3].

The wide use of stochastic policies in prior work makes the introductory explanation of the potential benefits for stochastic policies distracting,

instead the focus should be on the particular choice and benefits of the particular stochastic parametrization chosen here and the choice of stochastic value gradient as a training method (as opposed to many on-policy methods).

The empirical comparison is also hampered by only comparing with DDPG,

there are numerous stochastic policy algorithms that have been compared on these environments.

Additionally, the DDPG performance here is lower for several environments than the results reported in Henderson et al. 2017 (cited in the paper, table 2 here, table 3 Henderson)

which should be explained.

While this particular parametrization may provide some benefits, the lack of engagement with relevant prior work and other stochastic baselines significant limits the impact of this work and makes assessing its significance difficult.

This work would benefit from careful copyediting.

[1] Heess, N., Wayne, G., Silver, D., Lillicrap, T., Erez, T., & Tassa, Y. (2015). Learning continuous control policies by stochastic value gradients. In Advances in Neural Information Processing Systems (pp. 2944-2952).

[2] Mnih, V., Badia, A. P., Mirza, M., Graves, A., Lillicrap, T., Harley, T., ... & Kavukcuoglu, K. (2016, June). Asynchronous methods for deep reinforcement learning. In International Conference on Machine Learning (pp. 1928-1937).

[3] Schulman, J., Moritz, P., Levine, S., Jordan, M., & Abbeel, P. (2015). High-dimensional continuous control using generalized advantage estimation. arXiv preprint arXiv:1506.02438.

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


## Review Summary Overall, the paper's paper core claim, that increasing batch sizes at a linear rate during training is as effective as decaying learning rates, isinteresting

but doesn't seem to be too surprising given other recent work in this space.

The most useful part of the paper is the empirical evidence to backup this claim,

which I can't easily find in previous literature.

I wish the paper had explored a wider variety of dataset tasks and models to better show how well this claim generalizes, better situated the practical benefits of the approach

(how much wallclock time is actually saved?

how well can it be integrated into a distributed workflow?),

and included some comparisons with other recent recommended ways to increase batch size over time.

## Pros / Strengths + effort to assess momentum / Adam / other modern methods

+ effort to compare to previous experimental setups

## Cons / Limitations - lack of wallclock measurements in experiments

- only ~2 models / datasets examined,

so difficult to assess generalization

- lack of discussion about distributed/asynchronous SGD

## Significance Many recent previous efforts have looked at the importance of batch sizes during training,

so topic is relevant to the community.

Smith and Le (2017) present a differential equation model for the scale of gradients in SGD,finding a linear scaling rule proportional to eps N/B, where eps = learning rate, N = training set size, and B = batch size.

Goyal et al (2017) show how to train deep models on ImageNet effectively with large (but fixed) batch sizes by using a linear scaling rule.

A few recent works have directly tested increasing batch sizes during training.

De et al (AISTATS 2017) have a method for gradually increasing batch sizes, as do Friedlander and Schmidt (2012).

Thus, it is already reasonable to practitioners that the proposed linear scaling of batch sizes during training would be effective.

While increasing batch size at the proposed linear scale is simple and seems to be effective,

a careful reader will be curious how much more could be gained from the backtracking line search method proposed in De et al.

## Quality Overall, only single training runs from a random initialization are used.

It would be better to take the best of many runs or to somehow show error bars,

to avoid the reader wondering whether gains are due to changes in algorithm or to poor exploration due to bad initialization.

This happens a lot in Sec. 5.2.

Some of the experimental setting seem a bit haphazard and not very systematic.

In Sec. 5.2, only two learning rate scales are tested (0.1 and 0.5).

Why not examine a more thorough range of values?

Why not report actual wallclock times?

Of course having reduced number of parameter updates is useful,

but it's difficult to tell how big of a win this could be.

What about distributed SGD or asyncronous SGD (hogwild)?

Small batch sizes sometimes make it easier for many machines to be working simultaneously.

If we scale up to batch sizes of ~ N/10, we can only get 10x speedups in parallelization (in terms of number of parameter updates).

I think there is some subtle but important discussion needed on how this framework fits into modern distributed systems for SGD.

## Clarity Overall the paper reads reasonably well.

Offering a related work "feature matrix" that helps readers keep track of how previous efforts scale learning rates or minibatch sizes for specific experiments could be valueable.

Right now, lots of this information is just provided in text,

so it's not easy to make head-to-head comparisons.

Several figure captions should be updated to clarify which model and dataset are studied.

For example, when skimming Fig. 3's caption there is no such information.

## Paper Summary The paper examines the influence of batch size on the behavior of stochastic gradient descent to minimize cost functions.

The central thesis is that instead of the "conventional wisdom" to fix the batch size during training and decay the learning rate, it is equally effective (in terms of training/test error reached) to gradually increase batch size during training while fixing the learning rate.

These two strategies are thus "equivalent".

Furthermore, using larger batches means fewer parameter updates per epoch,

so training is potentially much faster.

Section 2 motivates the suggested linear scaling using previous SGD analysis from Smith and Le (2017).

Section 3 makes connections to previous work on finding optimal batch sizes to close the generaization gap.

Section 4 extends analysis to include SGD methods with momentum.

In Section 5.1, experiments training a 16-4 ResNet on CIFAR-10 compare three possible SGD schedules:

* increasing batch size * decaying learning rate * hybrid (increasing batch size and decaying learning rate)

Fig. 2, 3 and 4 show that across a range of SGD variants (+/- momentum, etc) these three schedules have similar error vs. epoch curves.

This is the core claimed contribution: empirical evidence that these strategies are "equivalent".

In Section 5.3, experiments look at Inception-ResNet-V2 on ImageNet,

showing the proposed approach can reach comparable accuracies to previous work at even fewer parameter updates (2500 here, vs. ∼14000 for Goyal et al 2007)

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