This paper proposes the concept of optimal representation space and suggests that a model should be evaluated in its optimal representation space to get good performance.

It could be a good idea if this paper could suggest some ways to find the optimal representation space in general, instead of just showing two cases.

It is disappointing, because this paper is named as "finding optimal representation spaces ...".

In addition, one of the contributions claimed in this paper is about introducing the "formalism" of an optimal representation space.

However, I didn't see any formal definition of this concept or theoretical justification.

About FastSent or any other log-linear model, the reason that dot product (or cosine similarity) is a good metric is because the model is trained to optimize the dot product, as shown in equation 5

--- I think this simple fact is missed in this paper.

The experimental results are not convincing,

because I didn't find any consistent pattern that shows the performance is getting better once we evaluated the model in its optimal representation space.

There are statements in this paper that I didn't agree with

1) Distributional hypothesis from Harris (1954) is about words not sentences.

2) Not sure the following line makes sense:

"However, these unsupervised tasks are more interesting from a general AI point of view, as they test whether the machine truly understands the human notion of similarity, without being explicitly told what is similar"

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


The paper proposes a deep learning framework called DeePa that supports multiple dimensions of parallelism in computation to accelerate training of convolutional neural networks.

Whereas the majority of work on parallel or distributed deep learning partitions training over bootstrap samples of training data (called image parallelism in the paper),

DeePa is able to additionally partition the operations over image height, width and channel.

This gives more options to parallelize different parts of the neural network.

For example, the best DeePa configurations studied in the paper for AlexNet, VGG-16, and Inception-v3 typically use image parallelism for the initial layers, reduce GPU utilization for the deeper layers to reduce data transfer overhead, and use model parallelism on a smaller number of GPUs for fully connected layers.

The net is that DeePa allows such configurations to be created that provide an increase in training throughput and lower data transfer in practice for training these networks.

These configurations for parellism are not easily programmed in other frameworks like TensorFlow and PyTorch.

The paper can potentially be improved in a few ways.

One is to explore more demanding training workloads that require larger-scale distribution and parallelism.

The ImageNet 22-K would be a good example and would really highlight the benefits of the DeePa in practice.

Beyond that, more complex workloads like 3D CNNs for video modeling would also provide a strong motivation for having multiple dimensions of the data for partitioning operations.

fact fact fact fact fact fact evaluation evaluation request evaluation request


*Summary* The paper proposes to use hyper-networks [Ha et al. 2016] for the tuning of hyper-parameters, along the lines of [Brock et al. 2017].

The core idea is to have a side neural network sufficiently expressive to learn the (large-scale, matrix-valued) mapping from a given configuration of hyper-parameters to the weights of the model we wish to tune.

The paper gives a theoretical justification of its approach,

and then describes several variants of its core algorithm which mix the training of the hyper-networks together with the optimization of the hyper-parameters themselves.

Finally, experiments based on MNIST illustrate the properties of the proposed approach.

While the core idea may appear as appealing,

the paper suffers from several flaws (as further detailed afterwards):

-Insufficient related work

-Correctness/rigor of Theorem 2.1

-Clarity of the paper (e.g., Sec. 2.4)

-Experiments look somewhat artificial

-How scalable is the proposed approach in the perspective of tuning models way larger/more complex than those treated in the experiments?

*Detailed comments* -"...and training the model to completion." and "This is wasteful, since it trains the model from scratch each time..." (and similar statement in Sec. 2.1):

Those statements are quite debatable.

There are lines of work, e.g., in Bayesian optimization, to model early stopping/learning curves (e.g., Domhan2014, Klein2017 and references therein) and where training procedures are explicitly resumed (e.g., Swersky2014, Li2016).

The paper should reformulate its statements in the light of this literature.

-"Uncertainty could conceivably be incorporated into the hypernet...".

This seems indeed an important point,

but it does not appear as clear how to proceed (e.g., uncertainty on w_phi(lambda) which later needs to propagated to L_val);

could the authors perhaps further elaborate?

-I am concerned about the rigor/correctness of Theorem 2.1;

for instance, how is the continuity of the best-response exploited?

Also, throughout the paper, the argmin is defined as if it was a singleton

while in practice it is rather a set-valued mapping (except if there is a unique minimizer for L_train(., lambda),

which is unlikely to be the case given the nature of the considered neural-net model).

In the same vein, Jensen's inequality states that Expectation[g(X)] >= g(Expectation[X]) for some convex function g and random variable X;

how does it precisely translate into the paper's setting (convexity, which function g, etc.)?

-Specify in Alg. 1 that "hyperopt" refers to a generic hyper-parameter procedure.

-More details should be provided to better understand Sec. 2.4.

At the moment, it is difficult to figure out (and potentially reproduce) the model which is proposed.

-The training procedure in Sec. 4.2 seems quite ad hoc;

how sensitive was the overall performance with respect to the optimization strategy?

For instance, in 4.2 and 4.3, different optimization parameters are chosen.

-typo: "weight decay is applied the..." --> "weight decay is applied to the..."

-"a standard Bayesian optimization implementation from sklearn": Could more details be provided?

(there does not seem to be implementation there http://scikit-learn.org/stable/model_selection.html to the best of my knowledge)

-The experimental set up looks a bit far-fetched and unrealistic:

first scalar, than diagonal and finally matrix-weighted regularization schemes.

While the first two may be used in practice,

the third scheme is not used in practice to the best of my knowledge.

-typo: "fit a hypernet same dataset." --> "fit a hypernet on the same dataset."

-(Franceschi2017) could be added to the related work section.

*References* (Domhan2014) Domhan, T.; Springenberg, T. & Hutter, F. Extrapolating learning curves of deep neural networks ICML 2014 AutoML Workshop, 2014

(Franceschi2017) Franceschi, L.; Donini, M.; Frasconi, P. & Pontil, M. Forward and Reverse Gradient-Based Hyperparameter Optimization preprint arXiv:1703.01785, 2017

(Klein2017) Klein, A.; Falkner, S.; Springenberg, J. T. & Hutter, F. Learning curve prediction with Bayesian neural networks International Conference on Learning Representations (ICLR), 2017, 17

(Li2016) Li, L.; Jamieson, K.; DeSalvo, G.; Rostamizadeh, A. & Talwalkar, A. Hyperband: A Novel Bandit-Based Approach to Hyperparameter Optimization preprint arXiv:1603.06560, 2016

(Swersky2014) Swersky, K.; Snoek, J. & Adams, R. P. Freeze-Thaw Bayesian Optimization preprint arXiv:1406.3896, 2014

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


The authors propose a new network architecture for RL that contains some relevant inductive biases about planning.

This fits into the recent line of work on implicit planning where forms of models are learned to be useful for a prediction/planning task.

The proposed architecture performs something analogous to a full-width tree search using an abstract model (learned end-to-end).

This is done by expanding all possible transitions to a fixed depth before performing a max backup on all expanded nodes.

The final backup value is the Q-value prediction for a given state, or can represent a policy through a softmax.

I thought the paper was clear and well-motivated.

The architecture (and various associated tricks like state vector normalization) are well-described for reproducibility.

Experimental results seem promising

but I wasn’t fully convinced of its conclusions.

In both domains, TreeQN and AtreeC are compared to a DQN architecture,

but it wasn’t clear to me that this is the right baseline.

Indeed TreeQN and AtreeC share the same conv stack in the encoder (I think?),

but also have the extra capacity of the tree on top.

Can the performance gain we see in the Push task as a function of tree depth be explained by the added network capacity?

Same comment in Atari,

but there it’s not really obvious that the proposed architecture is helping.

Baselines could include unsharing the weights in the tree, removing the max backup, having a regular MLP with similar capacity, etc.

Page 5, the auxiliary loss on reward prediction seems appropriate,

but it’s not clear from the text and experiments whether it actually was necessary.

Is it that makes interpretability of the model easier (like we see in Fig 5c)?

Or does it actually lead to better performance?

Despite some shortcomings in the result section, I believe this is good work and worth communicating as is.

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


This paper studies learning to play two-player general-sum games with state (Markov games).

The idea is to learn to cooperate (think prisoner's dilemma) but in more complex domains.

Generally, in repeated prisoner's dilemma, one can punish one's opponent for noncooperation.

In this paper, they design an apporach to learn to cooperate in a more complex game, like a hybrid pong meets prisoner's dilemma game.

This is fun but I did not find it particularly surprising from a game-theoretic or from a deep learning point of view.

From a game-theoretic point of view, the paper begins with somewhat sloppy definitions followed by a theorem that is not very surprising.

It is basically a straightforward generalization of the idea of punishing, which is common in "folk theorems" from game theory, to give a particular equilibrium for cooperating in Markov games.

Many Markov games do not have a cooperative equilibrium, so this paper restricts attention to those that do.

Even in games where there is a cooperative solution that maximizes the total welfare, it is not clear why players would choose to do so.

When the game is symmetric, this might be "the natural" solution

but in general it is far from clear why all players would want to maximize the total payoff.

The paper follows with some fun experiments implementing these new game theory notions.

Unfortunately, since the game theory was not particularly well-motivated,

I did not find the overall story compelling.

It is perhaps interesting that one can make deep learning learn to cooperate,

but one could have illustrated the game theory equally well with other techniques.

In contrast, the paper "Coco-Q: Learning in Stochastic Games with Side Payments" by Sodomka et. al. is an example where they took a well-motivated game theoretic cooperative solution concept and explored how to implement that with reinforcement learning.

I would think that generalizing such solution concepts to stochastic games and/or deep learning might be more interesting.

It should also be noted that I was asked to review another ICLR submission entitled "CONSEQUENTIALIST CONDITIONAL COOPERATION IN SOCIAL DILEMMAS WITH IMPERFECT INFORMATION"

which amazingly introduced the same "Pong Player’s Dilemma" game as in this paper.

Notice the following suspiciously similar paragraphs from the two papers:From "MAINTAINING COOPERATION IN COMPLEX SOCIAL DILEMMAS USING DEEP REINFORCEMENT LEARNING":

We also look at an environment where strategies must be learned from raw pixels.

We use the method of Tampuu et al. (2017) to alter the reward structure of Atari Pong so that whenever an agent scores a point they receive a reward of 1 and the other player receives −2.

We refer to this game as the Pong Player’s Dilemma (PPD).

In the PPD the only (jointly) winning move is not to play.

However, a fully cooperative agent can be exploited by a defector.

From "CONSEQUENTIALIST CONDITIONAL COOPERATION IN SOCIAL DILEMMAS WITH IMPERFECT INFORMATION":

To demonstrate this we follow the method of Tampuu et al. (2017) to construct a version of Atari Pong which makes the game into a social dilemma.

In what we call the Pong Player’s Dilemma (PPD) when an agent scores they gain a reward of 1 but the partner receives a reward of −2.

Thus, in the PPD the only (jointly) winning move is not to play,

but selfish agents are again tempted to defect and try to score points even though this decreases total social reward.

We see that CCC is a successful, robust, and simple strategy in this game.

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


This paper proposes a new theoretically-motivated method for combining reinforcement learning and imitation learning for acquiring policies that are as good as or superior to the expert.

The method assumes access to an expert value function (which could be trained using expert roll-outs) and uses the value function to shape the reward function and allow for truncated-horizon policy search.

The algorithm can gracefully handle suboptimal demonstrations/value functions,

since the demonstrations are only used for reward shaping,

and the experiments demonstrate faster convergence and better performance compared to RL and AggreVaTeD on a range of simulated control domains.

The paper is well-written and easy to understand.

My main feedback is with regard to the experiments: I appreciate that the experiments used 25 random seeds!

This provides a convincing evaluation.

It would be nice to see experimental results on even higher dimensional domains such as the ant, humanoid, or vision-based tasks,

since the experiments seem to suggest that the benefit of the proposed method is diminished in the swimmer and hopper domains compared to the simpler settings.

Since the method uses demonstrations,

it would be nice to see three additional comparisons: (a) training with supervised learning on the expert roll-outs, (b) initializing THOR and AggreVaTeD (k=1) with a policy trained with supervised learning, and (c) initializing TRPO with a policy trained with supervised learning.

There doesn't seem to be any reason not to initialize in such a way, when expert demonstrations are available,

and such an initialization should likely provide a significant speed boost in training for all methods.

How many demonstrations were used for training the value function in each domain?

I did not see this information in the paper.

With regard to the method and discussion: The paper discusses the connection between the proposed method and short-horizon imitation and long-horizon RL, describing the method as a midway point.

It would also be interesting to see a discussion of the relation to inverse RL,

which considers long-term outcomes from expert demonstrations.

For example, MacGlashn & Littman propose a midway point between imitation and inverse RL [1].

Theoretically, would it make sense to anneal k from small to large? (to learn the most effectively from the smallest amount of experience)

[1] https://www.ijcai.org/Proceedings/15/Papers/519.pdf

Minor feedback: - The RHS of the first inequality in the proof of Thm 3.3 seems to have an error in the indexing of i and exponent, which differs from the line before and line after

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


The authors propose a procedure to generate an ensemble of sparse structured models.

To do this, the authors propose to (1) sample models using SG-MCMC with group sparse prior, (2) prune hidden units with small weights, (3) and retrain weights by optimizing each pruned model.

The ensemble is applied to MNIST classification and language modelling on PTB dataset.

I have two major concerns on the paper.

First, the proposed procedure is quite empirically designed.

So, it is difficult to understand why it works well in some problems.

Particularly. the justification on the retraining phase is weak.

It seems more like to use SG-MCMC to *initialize* models which will then be *optimized* to find MAP with the sparse-model constraints.

The second problem is about the baselines in the MNIST experiments.

The FNN-300-100 model without dropout, batch-norm, etc. seems unreasonably weak baseline.

So, the results on Table 1 on this small network is not much informative practically.

Lastly, I also found a significant effort is also desired to improve the writing.

The following reference also needs to be discussed in the context of using SG-MCMC in RNN.

- "Scalable Bayesian Learning of Recurrent Neural Networks for Language Modeling", Zhe Gan*, Chunyuan Li*, Changyou Chen, Yunchen Pu, Qinliang Su, Lawrence Carin

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


The quality of the paper is good, and clarity is mostly good.

The proposed metric is interesting,

but it is hard to judge the significance without more thorough experiments demonstrating that it works in practice.

Pros:- clear definitions of terms

- overall outline of paper is good

- novel metric

Cons - text is a bit over-wordy, and flow/meaning sometimes get lost.

A strict editor would be helpful,

because the underlying content is good

- odd that your definition of generalization in GANs appears immediately preceding the section titled "Generalisation in GANs"

- the paragraph at the end of the "Generalisation in GANs" section is confusing.

I think this section and the previous ("The objective of unsupervised learning") could be combined, removing some repetition, adding some subtitles to improve clarity.

This would cut down the text a bit to make space for more experiments.

- why is your definition of generalization that the test set distance is strictly less than training set ?

I would think this should be less-than-or-equal

- there is a sentence that doesn't end at the top of p.3: "... the original GAN paper showed that [ends here]"

- should state in the abstract what your "notion of generalization" for gans is, instead of being vague about it

- more experiments showing a comparison of the proposed metric to others (e.g. inception score, Mturk assessments of sample quality, etc.) would be necessary to find the metric convincing

- what is a "pushforward measure"? (p.2)

- the related work section is well-written and interesting,

but it's a bit odd to have it at the end.

Earlier in the work (e.g. before experiments and discussion) would allow the comparison with MMD to inform the context of the introduction

- there are some errors in figures that I think were all mentioned by previous commentators.

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


Summary: The paper proposes a new dataset for reading comprehension, called DuoRC.

The questions and answers in the DuoRC dataset are created from different versions of a movie plot narrating the same underlying story.

The DuoRC dataset offers the following challenges compared to the existing reading comprehension (RC) datasets –

1) low lexical overlap between questions and their corresponding passages,

2) requires use of common-sense knowledge to answer the question,

3) requires reasoning across multiples sentences to answer the question,

4) consists of those questions as well that cannot be answered from the given passage.

The paper experiments with two types of models

– 1) a model which only predicts the span in a document and

2) a model which generates the answer after predicting the span.

Both these models are built off of an existing model on SQuAD – the Bidirectional Attention Flow (BiDAF) model.

The experimental results show that the span based model performs better than the model which generates the answers.

But the accuracy of both the models is significantly lower than that of their base model (BiDAF) on SQuAD, demonstrating the difficulty of the DuoRC dataset.

Strengths:1.	The data collection process is interesting.

The challenges in the proposed dataset as outlined in the paper seem worth pushing for.

2.	The paper is well written making it easy to follow.

3.	The experiments and analysis presented in the paper are insightful.

Weaknesses:1.	It would be good if the paper can throw some more light on the comparison between the existing MovieQA dataset and the proposed DuoRC dataset, other than the size.

2.	The dataset is motivated as consisting of four challenges (described in the summary above) that do not exist in the existing RC datasets.

However, the paper lacks an analysis on what percentage of questions in the proposed dataset belong to each category of the four challenges.

Such an analysis would helpful to accurately get an estimate of the proportion of these challenges in the dataset.

3.	It is not clear from the paper how should the questions which are unanswerable be evaluated.

As in, what should be the ground-truth answer against which the answers should such questions be evaluated.

Clearly, string matching would not work

because a model could say “don’t know” whereas some other model could say “unanswerable”.

So, does the training data have a particular string as the ground truth answer for such questions, so that a model can just be trained to spit out that particular string when it thinks it can’t answer the questions?

4.	One of the observations made in the paper is that “training on one dataset and evaluating on the other results in a drop in the performance.”

However, in table 4, evaluating on Paraphrase RC is better when trained on Self RC as opposed to when trained on Paraphrase RC.

This seems to be in conflict with the observation drawn in the paper.

Could authors please clarify this?

Also, could authors please throw some light on why this might be happening?

5.	In the third phase of data collection (Paraphrase RC), was waiting for 2-3 weeks the only step taken in order to ensure that the workers for this stage are different from those in stage 2, or was something more sophisticated implemented which did not allow a worker who has worked in stage 2 to be able to participate in stage 3?

6.	Typo: Dataset section, phrases --> phases

Overall: The challenges proposed in the DuoRC dataset are interesting.

The paper is well written

and the experiments are interesting.

However, there are some questions (as mentioned in the Weaknesses section) which need to be clarified before I can recommend acceptance for the paper.

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


This paper is about rethinking how to use encoder-decoder architectures for representation learning when the training objective contains a similarity between the decoder output and the encoding of something else.

For example, for the skip-thought RNN encoder-decoder that encodes a sentence and decodes neighboring sentences: rather than use the final encoder hidden state as the representation of the sentence, the paper uses some function of the decoder,

since the training objective is to maximize each dot product between a decoder hidden state and the embedding of a context word.

If dot product (or cosine similarity) is going to be used as the similarity function for the representation, then it makes more sense, the paper argues, to use the decoder hidden state(s) as the representation of the input sentence.

The paper considers both averaging and concatenating hidden states.

One difficulty here is that the neighboring sentences are typically not available in downstream tasks,

so the paper runs the decoder to produce a predicted sentence one word-at-a-time, using the predicted words as inputs to the decoder RNNs.

Then those decoder RNN hidden states are used via averaging or concatenation

as the representation of a sentence in downstream tasks.

This paper is a source of contributions,

but I think in its current form it is not yet ready for publication.

Pros: I think it makes sense to pay attention to the training objective when deciding how to use the model for downstream tasks.

I like the empirical investigation of combining RNN and BOW encoders and decoders.

The experimental results show that a single encoder-decoder model can be trained and then two different functions of it can be used at test time for different kinds of tasks (RNN-RNN for supervised transfer and RNN-RNN-mean for unsupervised transfer).

I think this is an interesting result.

Cons: I have several concerns.

The first relate to the theoretical arguments and their empirical support.

Regarding the theoretical arguments: First, the paper discusses the notion of an "optimal representation space" and describes the argument as theoretical,

but I don't see much of a theoretical argument here.

As far as I can tell, the paper does not formally define its terms or define in what sense the representation space is "optimal".

I can only find heuristic statements like those in the paragraph in Sec 3.2 that begins "These observations...".

What exactly is meant formally by statements like "any model where the decoder is log-linear with respect to the encoder" or "that distance is optimal with respect to the model’s objective"?

It seems like the paper may want to start with formal definitions of an encoder and a decoder, then define what is meant by a "decoder that is log-linear with respect to the encoder", and define what it means for a distance to be optimal with respect to a training objective.

That seems necessary in order to provide the foundation to make any theoretical statement about choices for encoders, decoders, and training objectives.

I am still not exactly sure what that theoretical statement might look like,

but maybe defining the terms would help the authors get started in heading toward the goal of defining a statement to prove.

Second, the paper's theoretical story seems to diverge almost immediately from the choices used in the model and experimental procedure.

For example, in Sec. 3.2, it is stated that cosine similarity "is the appropriate similarity measure in the case of log-linear decoders."

But the associated footnote (footnote 2) seems to admit a contradiction here by noting that actually the appropriate similarity measure is dot product:

"Evidently, the correct measure is actually the dot product."

This is a bit confusing.

It also raises a question: If cosine similarity will be used later for computing similarity, then why not try using cosine similarity in place of dot product in the model?

That is, replace "u_w \cdot h_i" in Eq. (2) with "cos(u_w, h_i)".

If the paper's story is correct (and if I understand the ideas correctly), training with cosine similarity should work better than training with dot product,

because the similarity function used during training is more similar to that used in testing.

This seems like a natural experiment to try.

Other natural experiments would be to vary both the similarity function used in the model during training and the similarity function used at test time.

The authors' claims could be validated if the optimal choices always use the same choice for the training and test-time similarity functions.

That is, if Euclidean distance is used during training, then will Euclidean distance be the best choice at test time?

Another example of the divergence lies in the use of the skip-thought decoder on downstream tasks.

Since the decoder hidden states depend on neighboring sentences and these are considered to be unavailable at test time,

the paper "unrolls" the decoder for several steps by using it to predict words which are then used as inputs on the next time step.

To me, this is a potentially very significant difference between training and testing.

Since much of the paper is about reconciling training and testing conditions in terms of the representation space and similarity function,

this difference feels like a divergence from the theoretical story.

It is only briefly mentioned at the end of Sec. 3.3 and then discussed again later in the experiments section.

I think this should be described in more detail in Section 3.3

because it is an important note about how the model will be used in practice.

It would be nice to be able to quantify the impact (of unrolling the decoder with predicted words) by, for example, using the decoder on a downstream evaluation dataset that has neighboring sentences in it.

Then the actual neighboring sentences can be used as inputs to the decoder when it is unrolled, which would be closer to the training conditions

and we could empirically see the difference.

Perhaps there is an evaluation dataset with ordered sentences so that the authors could empirically compare using real vs predicted inputs to the decoder on a downstream task?

The above experiments might help to better connect the experiments section with the theoretical arguments.

Other concerns, including more specific points, are below: Sec. 2: When describing inferior performance of RNN-based models on unsupervised sentence similarity tasks, the paper states: "While this shortcoming of SkipThought and RNN-based models in general has been pointed out, to the best of our knowledge, it has never been systematically addressed in the literature before."

The authors may want to check Wieting & Gimpel (2017) (and its related work) which investigates the inferiority of LSTMs compared to word averaging for unsupervised sentence similarity tasks.

They found that averaging the encoder hidden states can work better than using the final encoder hidden state;

the authors may want to try that as well.

Sec. 3.2: When describing FastSent, the paper includes "Due to the model's simplicity, it is particularly fast to train and evaluate, yet has shown state-of-the-art performance in unsupervised similarity tasks (Hill et al., 2015)."

I don't think it makes much sense to cite the SimLex-999 paper in this context,

as that is a word similarity task and that paper does not include any results of FastSent.

Maybe the Hill et al (2016) FastSent citation was meant instead?

But in that case, I don't think it is quite accurate to make the claim that FastSent is SOTA on unsupervised similarity tasks.

In the original FastSent paper (Hill et al., 2016), FastSent is not as good as CPHRASE or "DictRep BOW+embs" on average across the unsupervised sentence similarity evaluations.

FastSent is also not as good as sent2vec from Pagliardini et al (2017) or charagram-phrase from Wieting et al. (2016).

Sec. 3.3:In describing skip-thought, the paper states: "While computationally complex, it is currently the state-of-the-art model for supervised transfer tasks (Hill et al., 2016)."

I don't think it is accurate to state that skip-thought is still state-of-the-art for supervised transfer tasks, in light of recent work (Conneau et al., 2017; Gan et al., 2017).

Sec. 3.3:When discussing averaging the decoder hidden states, the paper states: "Intuitively, this corresponds to destroying the word order information the decoder has learned."

I'm not sure this strong language can be justified here.

Is there any evidence to suggest that averaging the decoder hidden states will destroy word order information?

The hidden states may be representing word order information in a way that is robust to averaging, i.e., in a way such that the average of the hidden states can still lead to the reconstruction of the word order.

Sec. 4: What does it mean to use an RNN encoder and a BOW decoder?

This seems to be a strongly-performing setting and competitive with RNN-mean,

but I don't know exactly what this means.

Minor things:Sec. 3.1:When defining v_w, it would be helpful to make explicit that it's in \mathbb{R}^d.

Sec. 4: For TREC question type classification, I think the correct citation should be Li & Roth (2002) instead of Vorhees (2002).

Sec. 5:I think there's a typo in the following sentence: "Our results show that, for example, the raw encoder output for SkipThought (RNN-RNN) achieves strong performance on supervised transfer, whilst its mean decoder output (RNN-mean) achieves strong performance on supervised transfer."

I think "unsupervised" was meant in the latter mention.

References: Conneau, A., Kiela, D., Schwenk, H., Barrault, L., & Bordes, A. (2017). Supervised Learning of Universal Sentence Representations from Natural Language Inference Data. EMNLP.

Gan, Z., Pu, Y., Henao, R., Li, C., He, X., & Carin, L. (2017). Learning generic sentence representations using convolutional neural networks. EMNLP.

Li, X., & Roth, D. (2002). Learning question classifiers. COLING.

Pagliardini, M., Gupta, P., & Jaggi, M. (2018). Unsupervised Learning of Sentence Embeddings using Compositional n-Gram Features. arXiv preprint arXiv:1703.02507.

Wieting, J., Bansal, M., Gimpel, K., & Livescu, K. (2016). Charagram: Embedding words and sentences via character n-grams. EMNLP.

Wieting, J., & Gimpel, K. (2017). Revisiting Recurrent Networks for Paraphrastic Sentence Embeddings. ACL.

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


Summary: This paper proposes an adversarial learning framework for machine comprehension task.

Specifically, authors consider a reader network which learns to answer the question by reading the passage and a narrator network which learns to obfuscate the passage so that the reader can fail in its task.

Authors report results in 3 different reading comprehension datasets

and the proposed learning framework results in improving the performance of GMemN2N.

My Comments: This paper is a direct application of adversarial learning to the task of reading comprehension.

It is a reasonable idea

and authors indeed show that it works.

1. The paper needs a lot of editing.

Please check the minor comments.

2. Why is the adversary called narrator network?

It is bit confusing

because the job of that network is to obfuscate the passage.

3. Why do you motivate the learning method using self-play?

This is just using the idea of adversarial learning (like GAN) and it is not related to self-play.

4. In section 2, first paragraph, authors mention that the narrator prevents catastrophic forgetting.

How is this happening?

Can you elaborate more?

5. The learning framework is not explained in a precise way.

What do you mean by re-initializing and retraining the narrator?

Isn’t it costly to reinitialize the network and retrain it for every turn?

How many such epochs are done?

You say that test set also contains obfuscated documents.

Is it only for the validation set?

Can you please explain if you use obfuscation when you report the final test performance too?

It would be more clear if you can provide a complete pseudo-code of the learning procedure.

6. How does the narrator choose which word to obfuscate?

Do you run the narrator model with all possible obfuscations and pick the best choice?

7. Why don’t you treat number of hops as a hyper-parameter and choose it based on validation set?

I would like to see the results in Table 1 where you choose number of hops for each of the three models based on validation set.

8. In figure 2, how are rounds constructed?

Does the model sees the same document again and again for 100 times or each time it sees a random document and you sample documents with replacement?

This will be clear if you provide the pseudo-code for learning.

9. I do not understand author's’ justification for figure-3.

Is it the case that the model learns to attend to last sentences for all the questions?

Or where it attends varies across examples?

10. Are you willing to release the code for reproducing the results?

Minor comments: Page 1, “exploit his own decision” should be “exploit its own decision”

In page 2, section 2.1, sentence starting with “Indeed, a too low percentage …” needs to be fixed.

Page 3, “forgetting is compensate” should be “forgetting is compensated”.

Page 4, “for one sentences” needs to be fixed.

Page 4, “unknow” should be “unknown”.

Page 4, “??” needs to be fixed.

Page 5, “for the two first datasets” needs to be fixed.

Table 1, “GMenN2N” should be “GMemN2N”.

In caption, is it mean accuracy or maximum accuracy?

Page 6, “dataset was achieves” needs to be fixed.

Page 7, “document by obfuscated this word” needs to be fixed.

Page 7, “overall aspect of the two first readers” needs to be fixed.

Page 8, last para, references needs to be fixed.

Page 9, first sentence, please check grammar.

Section 6.2, last sentence is irrelevant.

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


This work addresses an important and outstanding problem: accurate long-term forecasting using deep recurrent networks.

The technical approach seems well motivated, plausible, and potentially a good contribution,

but the experimental work has numerous weaknesses which limit the significance of the work in current form.

For one, the 3 datasets tested are not established as among the most suitable, well-recognized benchmarks for evaluating long-term forecasting.

It would be far more convincing if the author’s used well-established benchmark data, for which existing best methods have already been well-tuned to get their best results.

Otherwise, the reader is left with concerns that the author’s may not have used the best settings for the baseline method results reported, which indeed is a concern here (see below).

One weakness with the experiments is that it is not clear that they were fair to RNN or LSTM,

for example, in terms of giving them the same computation as the TT-RNNs.

Section Hyper-parameter Analysis” on page 7 explains that they determined best TT rank and lags via grid search.

But presumably larger values for rank and lag require more computation,

so to be fair to RNN and LSTM they should be given more computation as well, for example allowing them more hidden units than TT-RNNs get, so that overall computation cost is the same for all 3 methods.

As far as this reviewer can tell, the authors offer no experiments to show that a larger number of units for RNN or LSTM would not have helped them in improving long-term forecasting accuracies,

so this seems like a very serious and plausible concern.

Also, on page 6 the authors say that they tried ARMA but that it performed about 5% worse than LSTM, and thus dismissing direct comparisons of ARMA against TT-RNN.

But they are unclear whether they gave ARMA as much hyper-parameter tuning (e.g. for number of lags) via grid search as their proposed TT-RNN benefited from.

Again, the concern here is that the experiments are plausibly not being fair to all methods equally.

So, due to the weaknesses in the experimental work,

this work seems a bit premature.

It should more clearly establish that their proposed TT-RNN are indeed performing well compared to existing SOTA.

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


This paper is well constructed and written.

It consists of a number of broad ideas regarding density estimation using transformations of autoregressive networks.

Specifically, the authors examine models involving linear maps from past states (LAM) and recurrence relationships (RAM).

The critical insight is that the hidden states in the LAM are not coupled allowing considerable flexibility between consecutive conditional distributions.

This is at the expense of an increased number of parameters and a lack of information sharing.

In contrast, the RAM transfers information between conditional densities via the coupled hidden states allowing for more constrained smooth transitions.

The authors then explored a variety of transformations designed to increase the expressiveness of LAM and RAM.

The authors importantly note that one important restriction on the class of transformations is the ability to evaluate the Jacobian of the transformation efficiently.

A composite of transformations coupled with the LAM/RAM networks provides a highly expressive model for modelling arbitrary joint densities but retaining interpretable conditional structure.

There is a rich variety of synthetic and real data studies which demonstrate that LAM and RAM consistently rank amongst the top models demonstrating potential utility for this class of models.

Whilst the paper provides no definitive solutions, this is not the point of the work which seeks to provide a description of a general class of potentially useful models.

evaluation fact fact fact fact fact fact fact fact evaluation evaluation


CONTRIBUTION The main contribution of the paper is not clearly stated.

To the reviewer, It seems “life-long learning” is the same as “online learning”.

However, the whole paper does not define what “life-long learning” is.

The limited budget scheme is well established in the literature.

1. J. Hu, H. Yang, I. King, M. R. Lyu, and A. M.-C. So. Kernelized online imbalanced learning with fixed budgets. In AAAI, Austin Texas, USA, Jan. 25-30 2015.

2. Y. Engel, S. Mannor, and R. Meir. The kernel recursive least-squares algorithm. IEEE Transactions on Signal Processing, 52(8):2275–2285, 2004.

It is not clear what the new proposal in the paper.

WRITING QUALITY The paper is not well written in a good shape.

Many meanings of the equations are not stated clearly, e.g., $phi$ in eq. (7).

Furthermore, the equation in algorithm 2 is not well formatted.

DETAILED COMMENTS 1. The mapping function $phi$ appears in Eq. (1) without definition.

2. The last equation in pp. 3 defines the decision function f by an inner product.

In the equation, the notation x_t and i_t is not clearly defined.

More seriously, a comma is missed in the definition of the inner product.

3. Some equations are labeled but never referenced, e.g., Eq. (4).

4. The physical meaning of Eq.(7) is unclear.

However, this equation is the key proposal of the paper.

For example, what is the output of the Eq. (7)?

What is the main objective of Eq. (7)?

Moreover, what support vectors should be removed by optimizing Eq. (7)?

One main issue is that the notation $phi$ is not clearly defined.

The computation of f-y_r\phi(s_r) makes it hard to understand.

Especially,  the dimension of $phi$ in Eq.(7) is unknown.

ABOUT EXPERIMENTS 1.	It is unclear how to tune the hyperparameters.

2.	In Table 1, the results only report the standard deviation of AUC.

No standard deviations of nSV and Time are reported.

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


This paper studies new off-policy policy optimization algorithm using relative entropy objective and use EM algorithm to solve it.

The general idea is not new, aka, formulating the MDP problem as a probabilistic inference problem.

There are some technical questions: 1. For parametric EM case, there is asymptotic convergence guarantee to local optima case;

However, for nonparametric EM case, there is no guarantee for that.

This is the biggest concern I have for the theoretical justification of the paper.

2. In section 4, it is said that Retrace algorithm from Munos et al. (2016) is used for policy evaluation.

This is not true.

The Retrace algorithm, is per se, a value iteration algorithm.

I think the author could say using the policy evaluation version of Retrace, or use the truncated importance weights technique as used in Retrace algorithm, which is more accurate.

Besides, a minor point: Retrace algorithm is not off-policy stable with function approximation, as shown in several recent papers, such as “Convergent Tree-Backup and Retrace with Function Approximation”.

But this is a minor point if the author doesn’t emphasize too much about off-policy stability.

3. The shifting between the unconstrained multiplier formulation in Eq.9 to the constrained optimization formulation in Eq.10 should be clarified.

Usually, an in-depth analysis between the choice of \lambda in multiplier formulation and the \epsilon in the constraint should be discussed,

which is necessary for further theoretical analysis.

4. The experimental conclusions are conducted without sound evidence.

For example, the author claims the method to be 'highly data efficient' compared with existing approaches,

however, there is no strong evidence supporting this claim.

Overall, although the motivation of this paper is interesting,

I think there is still a lot of details to improve.

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


The manuscript proposes two objective functions based on the manifold assumption as defense mechanisms against adversarial examples.

The two objective functions are based on assigning low confidence values to points that are near or off the underlying (learned) data manifold while assigning high confidence values to points lying on the data manifold.

In particular, for an adversarial example that is distinguishable from the points on the manifold and assigned a low confidence by the model, is projected back onto the designated manifold such that the model assigns it a high confidence value.

The authors claim that the two objective functions proposed in this manuscript provide such a projection onto the desired manifold and assign high confidence for these adversarial points.

These mechanisms, together with the so-called shell wrapper around the model (a deep learning model in this case) will provide the desired defense mechanism against adversarial examples.

The manuscript at the current stage seems to be a preliminary work that is not well matured yet.

The manuscript is overly verbose and the arguments seem to be weak and not fully developed yet.

More importantly, the experiments are very preliminary and there is much more room to deliver more comprehensive and compelling experiments.

fact fact fact fact evaluation evaluation evaluation request


The main idea of this paper is to replace the feedforward summation

y = f(W*x + b) where x,y,b are vectors, W is a matrix by an integral \y = f(\int W \x + \b) where \x,\y,\b are functions, and W is a kernel.

A deep neural network with this integral feedforward is called a deep function machine.

The motivation is along the lines of functional PCA:

if the vector x was obtained by discretization of some function \x, then one encounters the curse of dimensionality as one obtains finer and finer discretization.

The idea of functional PCA is to view \x as a function is some appropriate Hilbert space, and expands it in some appropriate basis.

This way, finer discretization does not increase the dimension of \x (nor its approximation), but rather improves the resolution.

This paper takes this idea and applies it to deep neural networks.

Unfortunately, beyond rather obvious approximation results, the paper does not get major mileage out of this idea.

This approach amounts to a change of basis -

and therefore the resolution invariance is not surprising.

In the experiments, results of this method should be compared not against NNs trained on the data directly, but against NNs trained on dimension reduced version of the data (eg: first fixed number of PCA components).

Unfortunately, this was not done.

I suspect that in this case, the results would be very similar.

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


This paper introdues NoisyNets, that are neural networks whose parameters are perturbed by a parametric noise function, and they apply them to 3 state-of-the-art deep reinforcement learning algorithms: DQN, Dueling networks and A3C.

They obtain a substantial performance improvement over the baseline algorithms, without explaining clearly why.

The general concept is nice,

the paper is well written

and the experiments are convincing,

so to me this paper should be accepted, despite a weak analysis.

Below are my comments for the authors. ---------------------------------

General, conceptual comments: The second paragraph of the intro is rather nice,

but it might be updated with recent work about exploration in RL.

Note that more than 30 papers are submitted to ICLR 2018 mentionning this topic,

and many things have happened since this paper was posted on arxiv (see the "official comments" too).

p2: "our NoisyNet approach requires only one extra parameter per weight"

Parameters in a NN are mostly weights and biases,

so from this sentence one may understand that you close-to-double the number of parameters, which is not so few!

If this is not what you mean, you should reformulate...

p2: "Though these methods often rely on a non-trainable noise of vanishing size as opposed to NoisyNet which tunes the parameter of noise by gradient descent."

Two ideas seem to be collapsed here:

the idea of diminishing noise over an experiment, exploring first and exploiting later,

and the idea of adapting the amount of noise to a specific problem.

It should be made clearer whether NoisyNet can address both issues and whether other algorithms do so too...

In particular, an algorithm may adapt noise along an experiment or from an experiment to the next.

From Fig.3, one can see that having the same initial noise in all environments is not a good idea,

so the second mechanism may help much.

BTW, the short section in Appendix B about initialization of noisy networks should be moved into the main text.

p4: the presentation of NoisyNets is not so easy to follow and could be clarified in several respects:

- a picture could be given to better explain the structure of parameters, particularly in the case of factorised (factorized, factored?) Gaussian noise.

- I would start with the paragraph "Considering a linear layer [...] below)" and only after this I would introduce \theta and \xi as a more synthetic notation.

Later in the paper, you then have to state "...are now noted \xi" several times, which I found rather clumsy.

p5: Why do you use option (b) for DQN and Dueling and option (a) for A3C?

The reason why (if any) should be made clear from the clearer presentation required above.

By the way, a wild question: if you wanted to use NoisyNets in an actor-critic architecture like DDPG, would you put noise both in the actor and the critic?

The paragraph above Fig3 raises important questions which do not get a satisfactory answer.

Why is it that, in deterministic environments, the network does not converge to a deterministic policy, which should be able to perform better?

Why is it that the adequate level of noise changes depending on the environment?

By the way, are we sure that the curves of Fig3 correspond to some progress in noise tuning (that is, is the level of noise really "better" through time with these curves, or they they show something poorly correlated with the true reasons of success?)?

Finally, I would be glad to see the effect of your technique on algorithms like TRPO and PPO which require a stochastic policy for exploration,

and where I believe that the role of the KL divergence bound is mostly to prevent the level of stochasticity from collasping too quickly.

-----------------------------------Local comments: The first sentence may make the reader think you only know about 4-5 old works about exploration.

Pp. 1-2 : "the approach differs ... from variational inference. [...] It also differs variational inference..."

If you mean it differs from variational inference in two ways, the paragraph should be reorganized.

p2: "At a high level our algorithm induces a randomised network for exploration, with care exploration via randomised value functions can be provably-efficient with suitable linear basis (Osband et al., 2014)"

=> I don't understand this sentence at all.

At the top of p3, you may update your list with PPO and ACKTR, which are now "classical" baselines too.

Appendices A1 and A2 are a lot redundant with the main text (some sentences and equations are just copy-pasted),

this should be improved.

The best would be to need to reject nothing to the Appendix.

--------------------------------------- Typos, language issues: p2 the idea ... the optimization process have been => has

p2 Though these methods often rely on a non-trainable noise of vanishing size as opposed to NoisyNet which tunes the parameter of noise by gradient descent.

=> you should make a sentence...

p3 the the double-DQN

several times, an equation is cut over two lines, a line finishing with "=",

which is inelegant

You should deal better with appendices:

Every "Sec. Ax/By/Cz" should be replaced by "Appendix Ax/By/Cz".

Besides, the big table and the list of performances figures should themselves be put in two additional appendices

and you should refer to them as Appendix D or E rather than "the Appendix".

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


This paper presents a so-called cross-view training for semi-supervised deep models.

Experiments were conducted on various data sets

and experimental results were reported.

Pros:* Studying semi-supervised learning techniques for deep models is of practical significance.

Cons:* The novelty of this paper is marginal.

The use of unlabeled data is in fact a self-training process.

Leveraging the sub-regions of the image to improve performance is not new and has been widely-studied in image classification and retrieval.

* The proposed approach suffers from a technical weakness or flaw.

For the self-labeled data, the prediction of each view is enforced to be same as the assigned self-labeling.

However, since each view related to a sub-region of the image (especially when the model is not so deep), it is less likely for this region to contain the representation of the concepts

(e.g., some local region of an image with a horse may exhibit only grass);

enforcing the prediction of this view to be the same self-labeled concepts (e.g,“horse”) may drive the prediction away from what it should be

( e..g, it will make the network to predict grass as horse).

Such a flaw may affect the final performance of the proposed approach.

* The word “view” in this paper is misleading.

The “view” in this paper is corresponding to actually sub-regions in the images

* The experimental results indicate that the proposed approach fails to perform better than the compared baselines in table 2, which reduces the practical significance of the proposed approach.

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


This paper presents a nearest-neighbor based continuous control policy.

Two algorithms are presented: NN-1 runs open-loop trajectories from the beginning state,

and NN-2 runs a state-condition policy that retrieves nearest state-action tuples for each state.

The overall algorithm is very simple to implement and can do reasonably well on some simple control tasks,

but quickly gets overwhelmed by higher-dimensional and stochastic environments.

It is very similar to "Learning to Steer on Winding Tracks Using Semi-Parametric Control Policies" and is effectively an indirect form of tile coding (each could be seen as a fixed voronoi cell).

I am sure this idea has been tried before in the 90s

but I am not familiar enough with all the literature to find it

(A quick google search brings this up: Reinforcement Learning of Active Recognition Behaviors, with a chapter on nearest-neighbor lookup for policies: https://people.eecs.berkeley.edu/~trevor/papers/1997-045/node3.html).

Although I believe there is work to be done in the current round of RL research using nearest neighbor policies,

I don't believe this paper delves very far into pushing new ideas

(even a simple adaptive distance metric could have provided some interesting results, nevermind doing a learned metric in a latent space to allow for rapid retrainig of a policy on new domains....),

and for that reason I don't think it has a place as a conference paper at ICLR.

I would suggest its submission to a workshop where it might have more use triggering discussion of further work in this area.

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


There could be an interesting idea here,

but the limitations and applicability of the proposed approach are not clear yet.

More analysis should be done to clarify its potential.

Besides, the paper seriously needs to be reworked.

The text in general, but also the notation, should be improved.

In my opinion, the authors should explain how to apply their algorithm to more general network architectures, and test it, in particular to convnets.

An experiment on a modern dataset beyond MNIST would also be a welcome addition.

Some comments:- The method is present as a fully-connected network training procedure.

But the resulting network is not really fully-connected, but modular.

This is clear in Fig. 1 and in the explanation in Sect. 3.1.

The newly added hidden neurons at every iteration do not project to the previous pool of hidden neurons.

It should be stressed that the networks end up with this non-conventional “tiled” architecture.

Are there studies where the capacity of such networks is investigated, when all the weights are trained concurrently.

- It wasn’t clear to me whether the memory reallocation could be easily implemented in hardware.

A few references or remarks on this issue would be welcome.

- The work “Efficient supervised learning in networks with binary synapses” by Baldassi et al. (PNAS 2007) should be cited.

Although usually ignored by the deep learning community, it actually was a pioneering study on the use of low resolution weights during inference while allowing for auxiliary variables during learning.

- Coming back my main point above, I didn’t really get the discussion on Sect. 5.3.

Why didn’t the authors test their algorithm on a convnet?

Are there any obstacles in doing so?

It seems quite important to understand this point,

as the paper appeals to technical applications and convolution seems hard to sidestep currently.

- Fig. 3: xx-axis: define storage efficiency and storage requirement.

- Fig. 4: What’s an RSBL?

Acronyms should be defined.

- Overall, language and notation should really be refined.

I had a hard time reading Algorithm 1,

as the notation is not even defined anywhere.

And this problem extends throughout the paper.

For example, just looking at Sect. 4.1, “training and testing data x is normalized…”, if x is not properly defined, it’s best to omit it;

“… 2-dimentonal…”, at least major typos should be scanned and corrected.

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


SUMMARY. The paper presents an extension of word2vec for structured features.

The authors introduced a new compatibility function between features and, as in the skipgram approach, they propose a variation of negative sampling to deal with structured features.

The learned representation of features is tested on a recommendation-like task.

---------- OVERALL JUDGMENT The paper is not clear

and thus I am not sure what I can learn from it.

From what is written on the paper I have trouble to understand the definition of the model the authors propose and also an actual NLP task where the representation induced by the model can be useful.

For this reason, I would suggest the authors make clear with a more formal notation, and the use of examples, what the model is supposed to achieve.

---------- DETAILED COMMENTS When the authors refer to word2vec is not clear if they are referring to skipgram or cbow algorithm,

please make it clear.

Bottom of page one: "a positive example is 'semantic'",

please, use another expression to describe observable examples,

'semantic' does not make sense in this context.

Levi and Goldberg (2014)  do not say anything about factorization machines,

could the authors clarify this point?

Equation (4), what do i and j stand for?

what does \beta represent?

is it the embedding vector?

How is this formula related to skipgram or cbow?

The introduction of structured deep-in factorization machine should be more clear with examples that give the intuition on the rationale of the model.

The experimental section is rather poor,

first, the authors only compare themselves with word2ve (cbow),

it is not clear what the reader should learn from the results the authors got.

Finally, the most striking flaw of this paper is the lack of references to previous works on word embeddings and feature representation,

I would suggest the author check and compare themselves with previous work on this topic.

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


Twin Networks: Using the Future as a Regularizer

** PAPER SUMMARY ** The authors propose to regularize RNN for sequence prediction by forcing states of the main forward RNN to match the state of a secondary backward RNN.

Both RNNs are trained jointly and only the forward model is used at test time.

Experiments on conditional generation (speech recognition, image captioning), and unconditional generation (MNIST pixel RNN, language models) show the effectiveness of the regularizer.

** REVIEW SUMMARY ** The paper reads well, has sufficient reference.

The idea is simple and well explained.

Positive empirial results support the proposed regularizer.

** DETAILED REVIEW ** Overall, this is a good paper.

I have a few suggestions along the text but nothing major.

In related work, I would cite co-training approaches.

In effect, you have two view of a point in time, its past and its future and you force these two views to agree,

see  (Blum and Mitchell, 1998) or Xu, Chang, Dacheng Tao, and Chao Xu. "A survey on multi-view learning." arXiv preprint arXiv:1304.5634 (2013).

I would also relate your work to distillation/model compression which tries to get one network to behave like another.

On that point, is it important to train the forward and backward network jointly or could the backward network be pre-trained?

In section 2, it is not obvious to me that the regularizer (4) would not be ignored in absence of regularization on the output matrix.

I mean, the regularizer could push h^b to small norm, compensating with higher norm for the output word embeddings.

Could you comment why this would not happen?

In Section 4.2, you need to refer to Table 2 in the text.

You also need to define the evaluation metrics used.

In this section, why are you not reporting the results from the original Show&Tell paper?

How does your implementation compare to the original work?

On unconditional generation, your hypothesis on uncertainty is interesting and could be tested.

You could inject uncertainty in the captioning task for instance, e.g. consider that multiple version of each word e.g. dogA, dogB, docC which are alternatively used instead of dog with predefined substitution rates.

Would your regularizer still be helpful there?

At which point would it break?

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


The authors purpose a method for creating mini batches for a student network by using a second learned representation space to dynamically selecting  examples by their 'easiness and true diverseness'.

The framework is detailed

and results on MNIST, cifar10 and fashion-MNIST are presented.

The work presented is novel but there are some notable omissions:

- there are no specific numbers presented to back up the improvement claims;

graphs are presented but not specific numeric results

- there is limited discussion of the computational cost of the framework presented

- there is no comparison to a baseline in which the additional learning cycles used for learning the embedding are used for training the student model.

- only small data sets are evaluated.

This is unfortunate

because if there are to be large gains from this approach, it seems that they are more likely to be found in the domain of large scale problems, than toy data sets like mnist.

fact evaluation fact evaluation fact fact evaluation fact fact evaluation evaluation


This paper proposed a new optimization framework for semi-supervised learning based on derived inversion scheme for deep neural networks.

The numerical experiments show a significant improvement in accuracy of the approach.


The authors present an algorithm for training ensembles of policy networks that regularly mixes different policies in the ensemble together by distilling a mixture of two policies into a single policy network, adding it to the ensemble and selecting the strongest networks to remain (under certain definitions of a "strong" network).

The experiments compare favorably against PPO and A2C baselines on a variety of MuJoCo tasks,

although I would appreciate a wall-time comparison as well,

as training the "crossover" network is presumably time-consuming.

It seems that for much of the paper, the authors could dispense with the genetic terminology altogether - and I mean that as a compliment.

There are few if any valuable ideas in the field of evolutionary computing

and I am glad to see the authors use sensible gradient-based learning for GPO, even if it makes it depart from what many in the field would consider "evolutionary" computing.

Another point on terminology that is important to emphasize - the method for training the crossover network by direct supervised learning from expert trajectories is technically not imitation learning but behavioral cloning.

I would perhaps even call this a distillation network rather than a crossover network.

In many robotics tasks behavioral cloning is known for overfitting to expert trajectories,

but that may not be a problem in this setting as "expert" trajectories can be generated in unlimited quantities.

fact fact request evaluation evaluation evaluation evaluation fact evaluation fact fact


The authors report a number of experiments using off-the-shelf sentence embedding methods for performing extractive summarisation, using a number of simple methods for choosing the extracted sentences.

Unfortunately the contribution is too minor, and the work too incremental, to be worthy of a place at a top-tier international conference such as ICLR.

The overall presentation is also below the required standard.

The work would be better suited for a focused summarisation workshop,

where there would be more interest from the participants.

Some of the statements motivating the work are questionable.

I don't know if sentence vectors *in particular* have been especially successful in recent NLP (unless we count neural MT with attention as using "sentence vectors").

It's also not the case that the sentence reordering and text simplification problems have been solved, as is suggested on p.2.

The most effective method is a simple greedy technique.

I'm not sure I'd describe this as being "based on fundamental principles of vector semantics" (p.4).

The citations often have the authors mentioned twice.

The reference to "making or breaking applications" in the conclusion strikes me as premature to say the least.

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


This paper proposes to bring together multiple inductive biases that hope to correct for inconsistencies in sequence decoding.

Building on previous works that utilize modified objectives to generate sequences, this work proposes to optimize for the parameters of a pre-defined combination of various sub-objectives.

The human evaluation is straight-forward and meaningful to compensate for the well-known inaccuracies of automatic evaluation.

While the paper points out that they introduce multiple inductive biases that are useful to produce human-like sentences,

it is not entirely correct that the objective is being learnt as claimed in portions of the paper.

I would like this point to be clarified better in the paper.

I think showing results on grounded generation tasks like machine translation or image-captioning would make a stronger case for evaluating relevance.

I would like to see comparisons on these tasks.

fact fact evaluation fact evaluation request request request


This paper aims to learn hierarchical policies by using a recursive policy structure regulated by a stochastic temporal grammar.

The experiments show that the method is better than a flat policy for learning a simple set of block-related skills in minecraft (find, get, put, stack)

and generalizes better to a modification of the environment (size of room).

The sequence of subtasks generated by the policy are interpretable.\n\n

Strengths:\n- The grammar and policies are trained using a sparse reward upon task completion.

\n- The method is well ablated;

Figures 4 and 5 answered most questions I had while reading.\n

- Theoretically, the method makes few assumptions about the environment and the relationships between tasks.\n

- The interpretability of the final behaviors is a good result.

\n\nWeaknesses:\n- The implementation gives the agent a -0.5 reward if it generates a currently unexecutable goal g\u2019.

Providing this reward requires knowing the full state of the world.

If this hack is required, then this method would not be useful in a real world setting,

defeating the purpose of the sparse reward mentioned above.

I would really like to see how the method performs without this hack. \n

- There are no comparisons to other multitask or hierarchical methods.

Progressive Networks or Zero-Shot Task Generalization with Multi-Task Deep Reinforcement Learning seem like natural comparisons.\n

- A video to show what the environments and tasks look like during execution would be helpful.\n

- The performances of the different ablations are rather close.

Please a standard deviation over multiple training runs.

Also, why does figure 4.b not include a flat policy?\n

- The stages are ordered in a semantically meaningful order (find is the first stage),

but the authors claim that the order is arbitrary.

If this claim is going to be included in the paper, it needs to be proven (results shown for random orderings)

because right now I do not believe it.

\n\nQuality:\nThe method does provide hierarchical and interpretable policies for executing instructions,

this is a meaningful direction to work on.

\n\nClarity:\nAlthough the method is complicated, the paper was understandable.

\n\nOriginality and significance:\nAlthough the method is interesting, I am worried that the environment has been too tailored for the method,

and that it would fail in realistic scenarios.

The results would be more significant if the tasks had an additional degree of complexity,

e.g. \u201cput blue block next to the green block\u201d \u201cget the blue block in room 2\u201d.

Then the sequences of subtasks would be a bit less linear

(e.g., first need to find blue, then get, then find green, then put).

At the moment the tasks are barely more than the actions provided in the environment.

\n\nAnother impedance to the paper\u2019s significance is the number of hacks to make the method work

(ordering of stages, alternating policy optimization, first training each stage on only tasks of previous stage).

Because the method is only evaluated on one simple environment,

it unclear which hacks are for the method generally, and which hacks are for the method to work on the environment.

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


This paper suggests a simple yet effective approach for learning with weak supervision.

This learning scenario involves two datasets, one with clean data (i.e., labeled by the true function) and one with noisy data, collected using a weak source of supervision.

The suggested approach assumes a teacher and student networks,

and builds the final representation incrementally, by taking into account the "fidelity" of the weak label when training the student at the final step.

The fidelity score is given by the teacher, after being trained over the clean data,

and it's used to build a cost-sensitive loss function for the students.

The suggested method seems to work well on several document classification tasks.

Overall, I liked the paper.

I would like the authors to consider the following questions - - Over the last 10 years or so, many different frameworks for learning with weak supervision were suggested (e.g., indirect supervision, distant supervision, response-based, constraint-based, to name a few).

First, I'd suggest acknowledging these works and discussing the differences to your work.

Second - Is your approach applicable to these frameworks?

It would be an interesting to compare to one of those methods  (e.g., distant supervision for relation extraction using a knowledge base), and see if by incorporating fidelity score, results improve.

- Can this approach be applied to semi-supervised learning?

Is there a reason to assume the fidelity scores computed by the teacher would not improve the student in a self-training framework?

- The paper emphasizes that the teacher uses the student's initial representation, when trained over the clean data.

Is it clear that this step in needed?

Can you add an additional variant of your framework when the fidelity score are  computed by the teacher when trained from scratch?

using different architecture than the student?

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


Quality: The work focuses on a novel problem of generating text sample using GAN and a novel in-filling mechanism of words.

Using GAN to generate samples in adversarial setup in texts has been limited due to the mode collapse and training instability issues.

As a remedy to these problems an in-filling-task conditioning on the surrounding text has been proposed.

But, the use of the rewards at every time step (RL mechanism) to employ the actor-critic training procedure could be challenging computationally challenging.

Clarity: The mechanism of generating the text samples using the proposed methodology has been described clearly.

However the description of the reinforcement learning step could have been made a bit more clear.

Originality: The work indeed use a novel mechanism of in-filling via a conditioning approach to overcome the difficulties of GAN training in text settings.

There has been some work using GAN to generate adversarial examples in textual context too to check the robustness of classifiers.

How this current work compares with the existing such literature?

Significance: The research problem is indeed significant

since the use of GAN in generating adversarial examples in image analysis has been more prevalent compared to text settings.

Also, the proposed actor-critic training procedure via RL methodology is indeed significant from its application in natural language processing.

pros: (a) Human evaluations applications to several datasets show the usefulness of MaskGen over the maximum likelihood trained model in generating more realistic text samples.

(b) Using a novel in-filling procedure to overcome the complexities in GAN training.

(c) generation of high quality samples even with higher perplexity on ground truth set.

cons: (a) Use of rewards at every time step to the actor-critic training procure could be computationally expensive.

(b) How to overcome the situation where in-filling might introduce implausible text sequences with respect to the surrounding words?

(c) Depending on the Mask quality GAN can produce low quality samples.

Any practical way of choosing the mask?

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


This paper presents a method for clustering based on latent representations learned from the classification of transformed data after pseudo-labellisation corresponding to applied transformation.

Pipeline: -Data are augmented with domain-specific transformations.

For instance, in the case of MNIST, rotations with different degrees are applied.

All data are then labelled as "original" or "transformed by ...(specific transformation)".

-Classification task is performed with a neural network on augmented dataset according to the pseudo-labels.

-In parallel of the classification, the neural network also learns the latent representation in an unsupervised fashion.

-k-means clustering is performed on the representation space observed in the hidden layer preceding the augmented softmax layer.

Detailed Comments: (*) Pros -The method outperforms the state-of-art regarding unsupervised methods for handwritten digits clustering on MNIST.

-Use of ACOL and GAR is interesting, also the idea to make "labeled" data from unlabelled ones by using data augmentation.

(*) Cons -minor: in the title, I find the expression "unsupervised clustering" uselessly redundant since clustering is by definition unsupervised.

-Choice of datasets: we already obtained very good accuracy for the classification or clustering of handwritten digits.

This is not a very challenging task.

And just because something works on MNIST, does not mean it works in general.

What are the performances on more challenging datasets like colored images (CIFAR-10, labelMe, ImageNet, etc.)?

-This is not clear what is novel here

since ACOL and GAR already exist.

The novelty seems to be in the adaptation to GAR from the semi-supervised to the unsupervised setting with labels indicating if data have been transformed or not.

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


The paper proposed a copula-based modification to an existing deep variational information bottleneck model, such that the marginals of the variables of interest (x, y) are decoupled from the DVIB latent variable model, allowing the latent space to be more compact when compared to the non-modified version.

The experiments verified the relative compactness of the latent space, and also qualitatively shows that the learned latent features are more 'disentangled'.

However, I wonder how sensitive are the learned latent features to the hyper-parameters and optimizations?

Quality: Ok.

The claims appear to be sufficiently verified in the experiments.

However, it would have been great to have an experiment that actually makes use of the learned features to make predictions.

I struggle a little to see the relevance of the proposed method without a good motivating example.

Clarity: Below average.

Section 3 is a little hard to understand.

Is q(t|x) in Fig 1 a typo?

How about t_j in equation (5)?

There is a reference that appeared twice in the bibliography (1st and 2nd).

Originality and Significance: Average.

The paper (if I understood it correctly) appears to be mainly about borrowing the key ideas from Rey et. al. 2014 and applying it to the existing DVIB model.

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


In this paper, the authors present an analysis of SGD within an SDE framework.

The ideas and the presented results are interesting and are clearly of interest to the deep learning community.

The paper is well-written overall.

However, the paper has important problems.

1) The analysis is widely based on the recent paper by Mandt et al.

While being an interesting work on its own, the assumptions made in that paper are very strict and not very realistic.

For instance, the assumption that the stochastic gradient noise being Gaussian is very restrictive and trying to justify it just by the usual CLT is not convincing especially when the parameter space is extremely large,

the setting that is considered in the paper.

2) There is a mistake in the proof Theorem 1.

Even with the assumption that the gradient of sigma is bounded, eq 20 cannot be justified and the equality can only be "approximately equal to".

The result will only hold if sigma does not depend on theta.

However, letting sigma depend on theta is the only difference from Mandt et al.

On the other hand, with constant sigma the result is very trivial and can be found in any text book on SDEs (showing the Gibbs distribution).

Therefore, presenting it as a new result is misleading.

3) Even if the sigma is taken constant and theorem 1 is corrected, I don't think theorem 2 is conclusive.

Theorem 2 basically assumes that the distribution is locally a proper Gaussian (it is stated as locally convex, however it is taken as quadratic)

and the result just boils down to computing some probability under a Gaussian distribution,

which is still quite trivial.

Apart from this assumption not being very realistic,

the result does not justify the claims on "the probability of ending in a certain minimum"

-- which is on the other hand a vague statement.

First of all "ending in" a certain area depends on many different factors, such as the structure of the distribution, the initial point, the distance between the modes etc.

Also it is not very surprising that the inverse image of a wider Gaussian density is larger than of a pointy one.

This again does not justify the claims.

For instance consider a GMM with two components, where the means of the individual components are close to each other, but one component having a very large variance and a smaller weight, and the other one having a lower variance and higher weight.

With authors' claim, the algorithm should spend more time on the wider one,

however it is evident that this will not be the case.

4) There is a conceptual mistake that the authors assume that SGD will attain the exact stationary distribution even when the SDE is simulated by the fixed step-size Euler integrator.

As soon as one uses eta>0 the algorithm will never attain the stationary distribution of the continuous-time process, but will attain a stationary distribution that is close to the ideal one (of course with several smoothness, growth assumptions).

The error between the ideal distribution and the empirical distribution will be usually O(eta) depending on the assumption

and therefore changing eta will result in a different distribution than the ideal one.

With this in mind the stationary distributions for (eta/S) and (2eta/2S) will be clearly different.

The experiments are very interesting and I do not underestimate their value.

However, the current analysis unfortunately does not properly explain the rather strong claims of the authors, which is supposed to be the main contribution of this paper.

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


In the Following, pros and cons of the paper are presented.

Pros ------- 1. Many real-world applications.

2. Simple architecture and can be reproduced (if given enough details.)

Cons----------------------1. Ablation study showing whether bidirectional LSTM contributing to the similarity would be helpful.

2. Baseline is not strong.

How about using just LSTM?

4. It is suprising to see that only concatenation with MLP is used for optimization of capturing regularities across languages.

5. Equation-11 looks like softplus function more than vanilla ReLU.

6. How are the similarity assessments made in the gold standard dataset.

The cost function used only suggest binary assessments.

Please refer to some SemEval tasks for cross-lingual or cross-level assessments.

As binary assessments may not be a right measure to compare articles of two different lengths or languages.

Minor issues------------1. SNS is meant to be social networking sites?

2. In Section 2.2, it denote that 'as the figure demonstrates'.

No reference to the figure.

3. In Section 3, 'discussed in detail' pointed to Section 2.1 related work section.

Not clear what is discussed in detail there.

4. Reference to Google Translate API is wrong.

The paper requires more experimental analysis to judge the significance of the approach presented.

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


This paper uses an information geometric view on hierarchical models to discuss a bias - variance decomposition in Boltzmann machines,

presenting interesting conclusions,

whereby some more care appears to be needed for making these claims.

The paper arrives at the main conclusion that it is possible to reduce both the bias and the variance in a hierarchical model.

The discussion is not specific to deep learning nor to Boltzmann machines, but actually addresses hierarchical exponential family models.

The methods pertaining hierarchical models are interesting and presented in a clear way.

My concern are the following points: The main theorem presents only a lower bound, meaning that it provides no guarantee that the variance can indeed be reduced.

The paper seems to ignore that a model with hidden variables may be singular,

in which case the Fisher metric is not positive definite and the Cramer Rao bound has no meaning.

This interferes with the claims and derivations made in the paper in the case of models with hidden variables.

The problem seems to lie in the fact that the presented derivations assume that an optimal distribution in the data manifold is given (see Theorem 1 and proof), effectively making this a discussion about a fully observed hierarchical model.

In particular, it is not further specified how to obtain θˆB(s) in page 6 before (13).

Also, in page 5 the paper states that ``it is known that the EM-algorithm can obtain the global optimum of Equation (12) (Amari, 2016, Section 8.1.3)''.

However, what is shown in that reference is only that:  (Theorem 8.2., Amari, 2016) ``The KL-divergence decreases monotonically by repeating the E-step and the M-step. Hence, the algorithm converges to an equilibrium.''

A model with hidden variables can have several global and local optimisers

(see, e.g. https://arxiv.org/abs/1709.05276).

The critical points of the EM algorithm can have a non trivial structure,

as has been observed in the case of non negative rank matrix varieties

(see, e.g., https://arxiv.org/pdf/1312.5634.pdf).

OTHER In page 3, ``S_\beta is e-flat and S_\alpha ... '', should this not be the other way around?

(See also page 5 last paragraph of Section 2.)

Please also indicate the precise location in the provided reference.

All pages up to page 5 are introduction.

Section 2.3. as presented is very vague and does not add much to the discussion.

In page 7, please explain E ψ(θˆ )^2 −ψ(θ∗ )^2=0

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


1) Summary This paper proposes a recurrent neural network (RNN) training formulation for encouraging RNN the hidden representations to contain information useful for predicting future timesteps reliably.

The authors propose to train a forward and backward RNN in parallel.

The forward RNN predicts forward in time and the backward RNN predicts backwards in time.

While the forward RNN is trained to predict the next timestep,

its hidden representation is forced to be similar to the representation of the backward RNN in the same optimization step.

In experiments, it is shown that the proposed method improves training speed in terms of number of training iterations, achieves 0.8 CIDEr points improvement over baselines using the proposed training, and also achieves improved performance for the task of speech recognition.

2) Pros:+ Novel idea that makes sense for learning a more robust representation for predicting the future and prevent only local temporal correlations learned.

+ Informative analysis for clearly identifying the strengths of the proposed method and where it is failing to perform as expected.

+ Improved performance in speech recognition task.

+ The idea is clearly explained and well motivated.

3) Cons:Image captioning experiment:In the experimental section, there is an image captioning result in which the proposed method is used on top of two baselines.

This experiment shows improvement over such baselines,

however, the performance is still worse compared against baselines such as Lu et al, 2017 and Yao et al, 2016.

It would be optimal if the authors can use their training method on such baselines and show improved performance, or explain why this cannot be done.

Unconditioned generation experiments:In these experiments, sequential pixel-by-pixel MNIST generation is performed in which the proposed method did not help.

Because of this, two conditioned set ups are performed: 1) 25% of pixels are given before generation, and 2) 75% of pixels are given before generation.

The proposed method performs similar to the baseline in the 25% case, and better than the baseline in the 75% case.

For completeness, and to come to a stronger conclusion on how much uncertainty really affects the proposed method, this experiment needs a case in which 50% of the pixels are given.

Observing 25% of the pixels gives almost no information about the identity of the digit

and it makes sense that it’s hard to encode the future,

however, 50% of the pixels give a good idea of what the digit identity is.

If the authors believe that the 50% case is not necessary, please feel free to explain why.

Additional comments:The method is shown to converge faster compared to the baselines,

however, it is possible that the baseline may finish training faster

(the authors do acknowledge the additional computation needed in the backward RNN).

It would be informative for the research community to see the relationship of training time (how long it takes in hours) versus how fast it learns (iterations taken to learn).

Experiments on RL planning tasks would be interesting to see (Maybe on a simple/predictable environment).

4) Conclusion The paper proposes a method for training RNN architectures to better model the future in its internal state supervised by another RNN modeling the future in reverse.

Correctly modeling the future is very important for tasks that require making decisions of what to do in the future based on what we predict from the past.

The proposed method presents a possible way of better modeling the future,

however, some the results do not clearly back up the claim yet.

The given score will improve if the authors are able to address the stated issues.

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


The paper introduces a method for learning graph representations (i.e., vector representations for graphs).

An existing node embedding method is used to learn vector representations for the nodes.

The node embeddings are then projected into a 2-dimensional space by PCA.

The 2-dimensional space is binned using an imposed grid structure.

The value for a bin is the (normalized) number of nodes falling into the corresponding region.

The idea is simple and easily explained in a few minutes.

That is an advantage.

Also, the experimental results look quite promising.

It seems that the methods outperforms existing methods for learning graph representations.

The problem with the approach is that it is very ad-hoc.

There are several (existing) ideas of how to combine node representations into a representation for the entire graph.

For instance, averaging the node embeddings is something that has shown promising results in previous work.

Since the methods is so ad-hoc (node2vec -> PCA -> discretized density map -> CNN architecure) and since a theoretical understanding of why the approach works is missing, it is especially important to compare your method more thoroughly to simpler methods.

Again, pooling operations (average, max, etc.) on the learned node2vec embeddings are examples of simpler alternatives.

The experimental results are also not explained thoroughly enough.

For instance, since two runs of node2vec will give you highly varying embeddings (depending on the initialization), you will have to run node2vec several times to reduce the variance of your resulting discretized density maps.

How many times did you run node2vec on each graph?

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


In this paper the authors give a nice review of clustering methods with deep learning and a systematic taxonomy for existing methods.

Finally, the authors propose a new method by using one unexplored combination of taxonomy features.

The paper is well-written and easy to follow.

The proposed combination is straightforward,

but lack of novelty.

From table 1, it seems that the only differences between the proposed method and DEPICK is whether the method uses balanced assignment and pretraining.

I am not convinced that these changes will lead to a significant difference.

The performance of the proposed method and DEPICK are also similar in table 1.

In addition, the experiments section is not comprehensive enough as well.

the author only tested on two datasets.

More datasets should be tested for evaluation.

In addition, It seems that nearly all the experiments results from comparison methods are borrowed from the original publications.

The authors should finish the experiments on comparison methods and fill the entries in Table 1.

In summary, the proposed method is lack of novelty compare to existing methods.

The survey part is nice,

however extensive experiments should be conducted by running existing methods on different datasets and analyzing the pros and cons of the methods and their application scenarios.

Therefore, I think the paper cannot be accepted at this stage.

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