Bandits Dueling on Partially Ordered Sets
We address the problem of dueling bandits defined on partially ordered sets, or posets. In this setting, arms may not be comparable, and there may be several (incomparable) optimal arms. We propose an algorithm, UnchainedBandits, that efficiently finds the set of optimal arms -the Pareto front-of any poset even when pairs of comparable arms cannot be a priori distinguished from pairs of incomparable arms, with a set of minimal assumptions. This means that UnchainedBandits does not require information about comparability and can be used with limited knowledge of the poset. To achieve this, the algorithm relies on the concept of decoys, which stems from social psychology. We also provide theoretical guarantees on both the regret incurred and the number of comparison required by UnchainedBandits, and we report compelling empirical results.

The paper addresses a variant of the dueling bandit problem where certain comparisons are not resolvable by the algorithm. In other words, whereas dueling bandit algorithms deal with tournaments (i.e. fully connected directed graphs), the algorithms in this paper deal with more general directed graphs.
The authors offer only vague conceptual reasons for the significance of this new problem setting, however from a practical point of view, this is an extremely important problem that the existing literature does not address at all. More specifically, ties between arms are major stumbling blocks for most dueling bandit algorithms; indeed, many papers in the literature explicitly exclude problems with ties from their analyses. On the other hand, in practice one often has to deal with "virtual ties": these are pairs of arms that could not be distinguished from each other given the number of samples available to the algorithm.
A good example to keep in mind is a product manager at Bing or Google who has to pick the best ranker from a pool of a hundred proposed rankers using pairwise interleaved comparisons, but only has access to say %1 of the traffic for a week: if it happens to be that there are certain pairs of rankers in the pool that are so similar to each other that they couldn't be distinguished from each other even using the entirety of the available samples, then for all practical purposes the are ties in the resulting dueling bandit problem. So, our product manager would want an algorithm that would not waste the whole traffic on such virtual ties.
The authors propose two algorithms that deal with this problem under two different levels of generality:
1- an algorithm to find an \eps-approximation of the pareto front in the more general social poset setting, which is an extension of the Condorcet assumption in the full tournament case;
2- as algorithm to find the exact pareto front in the much more restrictive poset setting, which is an analogue of the total ordering assumption for regular dueling bandits.
I personally find the former much more interesting and important because there is plenty of experimental evidence that transitivity is very unlikely to hold in practice, although the second algorithm could lead to very interesting future work.
The authors use a peeling method that uses epochs with exponentially increasing lengths to gradually eliminate arms with smaller and smaller gaps. In the analysis, this has the effect of rendering the regret incurred from most edges in the comparison graph negligible, hence the linear dependence on the gaps in regret bounds. The price that one pays for this simpler proof technique is an extra factor of K, which in the worst case makes the bound of the form O(K^2 log T / \Delta).
As a general comment, I think it would be a good idea for the authors to devote more space in the paper to situating the results presented here with respect to the existing dueling bandit literature: I think that would be much more helpful to the reader than the lengthy discussion on decoys, for instance. In particular, there is a very precise lower bound proven for Condorcet dueling bandits in (Komiyama et al, COLT 2015), and I think it's important for the authors to specify the discrepancy between the result in Theorem 1 and this lower bound in the full tournament setting when \eps is smaller than the smallest gap in the preference matrix.
Furthermore, given the numerous open questions that arise out of this work, I highly recommend having a lengthier discussion of future work. For instance, there is some recent work on using Thompson Sampling for dueling bandits in (Wu and Liu, NIPS 2016) and it is an interesting question whether or not their methods could be extended to this setting. Moreover, it would be interesting to find out if more refined results for the von Neumann problem, such as those presented in (Balsubramani et al, COLT 2016) can be transported here.
Another criticism that I have of the write-up is that in the experiments it's not at all clear how IF2 and RUCB were modified, so please elaborate on the specifics of that.


Learning Spherical Convolution for Fast Features from 360°Imagery
While 360°cameras offer tremendous new possibilities in vision, graphics, and augmented reality, the spherical images they produce make core feature extraction non-trivial. Convolutional neural networks (CNNs) trained on images from perspective cameras yield "flat" filters, yet 360°images cannot be projected to a single plane without significant distortion. A naive solution that repeatedly projects the viewing sphere to all tangent planes is accurate, but much too computationally intensive for real problems. We propose to learn a spherical convolutional network that translates a planar CNN to process 360°imagery directly in its equirectangular projection. Our approach learns to reproduce the flat filter outputs on 360°d ata, sensitive to the varying distortion effects across the viewing sphere. The key benefits are 1) efficient feature extraction for 360°images and video, and 2) the ability to leverage powerful pre-trained networks researchers have carefully honed (together with massive labeled image training sets) for perspective images. We validate our approach compared to several alternative methods in terms of both raw CNN output accuracy as well as applying a state-of-the-art "flat" object detector to 360°data. Our method yields the most accurate results while saving orders of magnitude in computation versus the existing exact reprojection solution.

This paper describes a method to transform networks learned on perspective images to take spherical images as input. This is an important problem as fisheye and 360-degree sensors become more and more ubiquitous but training data is relatively scarce. The method first transforms the network architecture to adapt the filter sizes and pooling operations to convolutions on a equirectangular representation/projection. Next the filters are learned to match the feature responses of the original network when considering the projections to the tangent plane of the respective feature response. The filters are pre-learned layer-by-layer and fine-tuned to output features as similar as possible to the original network projected to the tangent planes. Detection experiments on Pano2Vid and PASCAL demonstrate that the technique performs slightly below the optimal performance using per-pixel tangent projections (however significantly faster) while outperforming several baselines, including cube map projections.
The paper is well written and largely easy to read. While simple and sometimes quite ad hoc (Sec 3.2), I like the idea and am not aware of any closely related work (though I am not an expert in that domain). The technical novelty is quite limited though as it largely boils down to retraining a newly structured network on equirectangular images based on a pre-trained model. I think the experiments still warrant publication (though I would have believed that a pure computer vision venue would be more appropriate than NIPS due to the specific application), so overall I am slightly on the positive side.
Detailed comments (in order of the paper):
Introduction: The upper bound the method can achieved is defined by running a CNN on all possible tangent projections. This seems fair, but does not deal with very large and close objects which would be quite distorted on the tangent plane (and occur frequently in 360 degree videos / GoPro Videos / etc). I don't think this is a weakness but maybe a comment on this might be good.
Related work: I am missing a section discussing related work on CNNs operating on distorted inputs and invariance of CNNs against geometric transformations, eg., spatial transformer networks, warped convolutions, and other works which consider invariance.
l. 117: W -> W x W pixels
Eq. 2: I find ":=" odd here, maybe just "=" or approximate? Also, it is a bit sloppy to have x/y on the lhs and \phi/\psi on the rhs without formalizing their connection in that context (it is only textual before). Maybe ok though.
After this equation there is some text describing the overall approach, but I couldn't fully grasp it at this point. I would add more information here, for example that the goal is to build a network on the equirectangular image and match the outputs after each convolution to the corresponding outputs of the CNN computed on the tangent plane.
Fig. 2b: It is unclear to me how such a distortion pattern (top image) can arise. Why are the boundaries so non-smooth (double curved left image boundary for instance). I don't see how this could arise.
Fig. 2 caption: It would be good to say "each row of the equirectangular image (ie, \phi)" and in (b) what is inversely projected.
l. 131: It is never clearly described how these true outputs are computed from exhaustive planar reprojections. Depending on the receptive field size, is a separate network run on each possible tangent plane? More details would be appreciated.
Sec. 3.2: I found the whole description quite ad-hoc and heuristic. I don't have a concrete comment for improvement here though except that it should be mentioned early on that this can only lead to an approximate result when minimizing the loss in the end.
l. 171: It is unclear here if the loss is over all feature maps (must be) and over all layers (probably not?). Also, how are the weights initialized? This seems never mentioned.
l. 182: It is unclear why and how max-pooling is replaced by dilated convolutions. One operation has parameters while the others has not.
l. 191: It is not Eq. 2 that is used but a loss that considers the difference between the lhs and the rhs of that equation I assume? Why not stating this explicitly or better reuse the equation from the beginning of Sec 3.3.?
l. 209: What happens to the regions with no content? Are they excluded or 0-padded?
l. 222: Why is detection performance evaluated as classification accuracy. Shouldn't this be average precision or alike?
Experiments: Some more qualitative results would be nice to shed some light. Maybe some space can be made by squeezing the text partially.


Gradient descent GAN optimization is locally stable
Despite the growing prominence of generative adversarial networks (GANs), optimization in GANs is still a poorly understood topic. In this paper, we analyze the "gradient descent" form of GAN optimization, i.e., the natural setting where we simultaneously take small gradient steps in both generator and discriminator parameters. We show that even though GAN optimization does not correspond to a convex-concave game (even for simple parameterizations), under proper conditions, equilibrium points of this optimization procedure are still locally asymptotically stable for the traditional GAN formulation. On the other hand, we show that the recently proposed Wasserstein GAN can have non-convergent limit cycles near equilibrium. Motivated by this stability analysis, we propose an additional regularization term for gradient descent GAN updates, which is able to guarantee local stability for both the WGAN and the traditional GAN, and also shows practical promise in speeding up convergence and addressing mode collapse.

The authors present a dynamical system based analysis of simultaneous gradient descent updates for GANs, by considering the limit dynamical system that corresponds to the discrete updates. They show that under a series of assumptions, an equilibrium point of the dynamical system is locally asymptotically stable, implying convergence to the equilibrium if the system is initialized in a close neighborhood of it. Then they show how some types of GANs fail to satisfy some of their conditions and propose a fix to the gradient updates that re-instate local stability. They give experimental evidence that the local-stability inspired fix yields improvements in practice on MNIST digit generation and simple multi-modal distributions.
However, I do think that these drawbacks are remedied by the fact that their modification, based on local asymptotic theory, did give noticeable improvements. Moreover, the local stability proof is a bit non-trivial from theoretical point of view.
I think this paper provides some nice theoretical results in GAN training and gives interesting insights to GAN training through the dynamical system lens. The most promising part of the paper is the fact that their theory inspired fix to gradient descent yields experimental improvements.
The theory part of the paper has some drawbacks: the assumptions that under equilibrium the discriminator outputs always zero is fairly strong and hard to believe in practice. In particular, it's hard to believe that the generator will be outputting a completely indistinguishable distribution from the real data, which is the only case where this could be an equilibrium for the discriminator. Also the fact that this is only a local stability without any arguments about the size of the region of attraction, might make the result irrelevant in practical training, where initializing in a tiny ball around the equilibrium would be impossible. Finally, it is not clear that local stability of the limit dynamical system will also imply local stability of the discrete system with stochastic gradients: if the variance in the stochastic gradient is large and the region of attraction is tiny, then a tiny step outside of the equilibrium together with a high variance gradient step could push the system outside of the region of attraction.


Non-Convex Finite-Sum Optimization Via SCSG Methods
We develop a class of algorithms, as variants of the stochastically controlled stochastic gradient (SCSG) methods [21], for the smooth non-convex finitesum optimization problem. Assuming the smoothness of each component, the complexity of SCSG to reach a stationary point with E ∇f (x) 2 ≤ ε is O min{ε −5/3 , ε −1 n 2/3 } , which strictly outperforms the stochastic gradient descent. Moreover, SCSG is never worse than the state-of-the-art methods based on variance reduction and it significantly outperforms them when the target accuracy is low. A similar acceleration is also achieved when the functions satisfy the Polyak-Lojasiewicz condition. Empirical experiments demonstrate that SCSG outperforms stochastic gradient methods on training multi-layers neural networks in terms of both training and validation loss.

Summary:
This paper proposes a variant of a family of stochastic optimization algorithms SCSG (closely related to SVRG), and analyzes it in the context of non-convex optimization. The main difference is that the outer loop computes a gradient on a random subset of the data, and the stochastic gradients in the inner loop have a random cardinality and are not restricted to those participating in the outer gradient. The analysis of the stochastic gradients despite this mismatch is the main technical contribution of the paper. The result is a set of new bounds on the performance of the algorithm which improve on both sgd and variance reduced algorithms, at least in the low-medium accuracy regimes. Experimental evidence supports the claims of improvement in objective reduction (both training error and test error) per iteration both before the end of the first pass on data and after, both by SCSG over SGD and by varying batch size variant over the fixed size variant, but only on two networks applied to the venerable and small MNIST dataset.
Pros of acceptance:
- The claimed results are interesting and shed light on an important regime.
- The proof method might be more widely applicable.
Cons:
- The experimental section is insufficient for the claims made.
Quality:
Theoretical contribution:
The main contribution of the paper seems to be an analysis of the discrepancy due to using partial long-term gradients, using the behavior of sampled means without replacement. If novel, this is a useful contribution to our understanding of a trick that is practically important for SVRG-type algorithms.
I’ve spot checked a few proofs in the supplementary material, and found a minor error:
-	Lemma B.3 assumes eta_j*L < 1, but table 2 does not mention L in giving the step sizes.
The empirical evaluation uses only one small and old dataset, which is bad methodology (there are many old small datasets, any reasonable algorithm will be good at one). Other than that, it is well designed, and the comparison in terms of number of gradients is reasonable, but should be complemented by a wall-time comparison as some algorithms have more overhead than others. The paper claims SCSG is never worse than SVRG and better in early stages; this justifies a direct comparison to SVRG (with B = n) for each part. An added plot in the existing comparison for early stages, and also a separate experiment that compares (on a log-log plot) the rates of local convergence to high precision inside a basin of attraction.
Clarity:
The paper is written quite well: the algorithm is clear including the comparison to previous variants of SCSG and of SVRG, the summary of bounds is helpful, and the presentation of bounds in appropriate detail in different parts.
Some minor comments:
-	L.28 table 1:
o	What is “best achievable” referring to in [26,27]? A lower bound? An algorithm proven optimal in some sense? should that be "best available" instead?
-	L.30 - 33: these sentences justify the comparison to SGD in a precision regime, but are not very clear. Substituting at the desired regime (eps = n^-1/2 or some such) would make the bounds directly comparable.
-	L.56 - 59 are confusing. Applying variance reduction in the non-convex is not novel.
-	Algorithm 1, L.2: \subset instead of \in, for consistency use the concise notation of 7.
-	L.106: “In order to minimize the amount the tuning works” something is wrong with that sentence.
-	L.116: “and the most of the novelty” first “the” is probably superfluous.
Supplementary material:
-	L.8 n should be M
-	L.13 B > 0 does not appear in the rest of the lemma or in the proof. Presume it is \gamma?
-
Originality:
I leave to reviewers more up to date with the non-convex literature to clarify whether the claimed novelties are such.
Significance:
This paper seems to complete the analysis of the existing SCSG, a practical SVRG variant, to the common non-convex regime. Specifically, showing theoretically that it improves on SGD in early stages is quite important.
-----
Updates made after rebuttal phase:
- The authors addressed the issues I'd raised with the proofs. One was a typo, one was a misinterpretation on my part. There may well still be quality issues, but they appear to be minor. I removed the corresponding con. I think the paper could be an 8 if its empirical evaluation was not so flawed.


Adaptive Classification for Prediction Under a Budget
We propose a novel adaptive approximation approach for test-time resourceconstrained prediction motivated by Mobile, IoT, health, security and other applications, where constraints in the form of computation, communication, latency and feature acquisition costs arise. We learn an adaptive low-cost system by training a gating and prediction model that limits utilization of a high-cost model to hard input instances and gates easy-to-handle input instances to a low-cost model. Our method is based on adaptively approximating the high-cost model in regions where low-cost models suffice for making highly accurate predictions. We pose an empirical loss minimization problem with cost constraints to jointly train gating and prediction models. On a number of benchmark datasets our method outperforms state-of-the-art achieving higher accuracy for the same cost.

1. Summary of paper
This paper introduced an adaptive method for learning two functions. First, a `cheap' classifier that incurs a small resource cost by using a small set of features. Second, a gating function that decides whether an input is easy enough to be sent to the cheap classifier or is too difficult and must be sent to a complex, resource-intensive classifier. In effect, this method bears a lot of similarity to a 2-stage cascade, where the first stage and the gating function are learned jointly.
2. High level subjective
The paper is written clearly for a reader familiar with budgeted learning, although I think a few parts of the paper are confusing (I'll go into this more below). I believe the idea of approximating an expensive, high-accuracy classifier is new (cascades are the most similar, but I believe cascades usually just consider using the same sort of classifiers in every stage). That said, it is very similar to a 2-stage cascade with different classifiers. I think there are certainly sufficient experiments demonstrating this method. Likely this method would be interesting to industry practitioners due to the increased generalization accuracy per cost.
3. High level technical
Why not try to learn a cost-constrained q function directly? If you removed the KL term and used q in the feature cost function instead of g, wouldn't you learn a q that tried as best to be accurate given the cost constraints? Did you learn a g separately in order to avoid some extra non-convexity? Or is it otherwise crucial? I would recommend explaining this choice more clearly.
I would have loved to see this model look less like a cascade. For instance, if there were multiple expensive 'experts' that were learned to be diverse w.r.t each other and then multiple gating functions along with a single cheap classifier were learned jointly, to send hard instances to one of the experts, then this would be a noticeable departure from a cascade. Right now I'm torn between liking this method and thinking it's a special cascade (using techniques from (Chen et al., 2012) and (Xu et al., 2012)).
4. Low level technical
- Line 161/162: I don't buy this quick sentence. I think this is much more complicated. Sure we can constrain F and G to have really simple learners but this won't constrain computation per instance, and the only guarantee you'll have is that your classifier is at most as computationally expensive as the most expensive classifier in F or G. You can do better by introducing computational cost terms into your objective.
- Line 177: There must be certain conditions required for alternating minimization to converge, maybe convexity and a decaying learning rate? I would just clarify that your problem satisfies these conditions.
- I think Figure 5 is a bit confusing. I would move Adapt_Gbrt RBF to the top of the second column in the legend, and put GreedyMiser in its original place. This way for every row except the last we are comparing the same adaptive/baseline method.
5. Summary of review
While this method achieves state-of-the-art accuracy in budgeted learning, it shares a lot of similarities with previous work (Chen et al., 2012) and (Xu et al., 2012) that ultimately harm its novelty.


Thy Friend is My Friend: Iterative Collaborative Filtering for Sparse Matrix Estimation
The sparse matrix estimation problem consists of estimating the distribution of an n × n matrix Y , from a sparsely observed single instance of this matrix where the entries of Y are independent random variables. This captures a wide array of problems; special instances include matrix completion in the context of recommendation systems, graphon estimation, and community detection in (mixed membership) stochastic block models. Inspired by classical collaborative filtering for recommendation systems, we propose a novel iterative, collaborative filteringstyle algorithm for matrix estimation in this generic setting. We show that the mean squared error (MSE) of our estimator converges to 0 at the rate of O(d 2 (pn) −2/5 ) as long as ω(d 5 n) random entries from a total of n 2 entries of Y are observed (uniformly sampled), E[Y ] has rank d, and the entries of Y have bounded support. The maximum squared error across all entries converges to 0 with high probability as long as we observe a little more, Ω(d 5 n ln 5 (n)) entries. Our results are the best known sample complexity results in this generality.

This paper studies a rather generic form of sparse matrix estimation problem. Inspired by [1-3], it suggests an algorithm that is roughly based on averaging matrix elements that are r-hop common neighbours of the two of nodes for which the estimate is being computed.
The authors then prove sample complexity bounds for the MSE to go to zero.
While there is a lot of related work in this direction the present paper discussed this nicely and treats the many cases in a unified framework and allows for generic noise function and sparser matrices. The paper provides (as far as I know) best bounds that hold in this generality. I think this is a very good paper that should be accepted.
Some comments suggesting improvements follow:
While in the sparse regime treating the generality of the noise is interesting and as far as I know original. It might be worth mentioning that in the denser case results on universality with respect to the noise are known for the matrix estimation problem ("MMSE of probabilistic low-rank matrix estimation: Universality with respect to the output channel" by Lesieur et al, and "Asymptotic mutual information for the two-groups stochastic block model" by Deshpande, Abbe, Montanari).
The algorithm seems related to a spectral algorithms designed for sparse graphs, based on the non-backtracking matrix. While the introduction mentions in only one sentence relation to only standard spectral algorithm, the relation to belief propagation and non-backtracking operator is discussed on page 6. At the same time the original works suggesting and analyzing those approaches are not cited there (i.e. "Spectral redemption in clustering sparse networks" by Krzakala et al, or "Non-backtracking spectrum of random graphs: community detection and non-regular Ramanujan graphs" by Bordenave et al.). This relation should perhaps be discussed in the section of related work or in the introduction and not in the section describing in details of the algorithm.
The introduction discusses an unpublished work on mixed membership SBM, in particular a gap between information theoretical lower bound and a conjectures algorithmic threshold in that case. Perhaps it should be mentioned that such results originate from the normal SBM where both the information-theoretic threshold for detection, and the conjectured algorithmic threshold were studied in detail, e.g. in "Asymptotic analysis of the stochastic block model for modular networks and its algorithmic applications" by Decelle et al.  Also in that case the gap between the two threshold is d (for large d).
While the main contribution of the paper is theoretical, it would have been nice to see some practical demonstration of the algorithm, comparison to other algorithms (at the same time this should not be used as an argument for rejection). Evidence of the scalability of the algorithm should be presented.
Minor points:
While the o(), O(), \Omega() notations are rather standard I was not very familiar with the \omega() and had to look it up to be sure. Perhaps more of NIPS audience would not be familiar with those and the definition could be shortly reminded.
I've read the author's feedback and took it into account in my score.


Towards Accurate Binary Convolutional Neural Network
We introduce a novel scheme to train binary convolutional neural networks (CNNs) -CNNs with weights and activations constrained to {-1,+1} at run-time. It has been known that using binary weights and activations drastically reduce memory size and accesses, and can replace arithmetic operations with more efficient bitwise operations, leading to much faster test-time inference and lower power consumption. However, previous works on binarizing CNNs usually result in severe prediction accuracy degradation. In this paper, we address this issue with two major innovations: (1) approximating full-precision weights with the linear combination of multiple binary weight bases; (2) employing multiple binary activations to alleviate information loss. The implementation of the resulting binary CNN, denoted as ABC-Net, is shown to achieve much closer performance to its full-precision counterpart, and even reach the comparable prediction accuracy on ImageNet and forest trail datasets, given adequate binary weight bases and activations.

The paper describes a new method for training binary convolutional neural networks. The scheme addresses both using binary weights and activations. The key insight here is to approximate the real valued weights via a linear combination of M binary basis weights. The coefficients for reconstructing the real weights can be found using least squares in the forward pass, and then pulled outside the convolution to allow for fast binary convolution at test time. A similar approach is taken for the activations, but in this case the weights and shifts are trained as normal during backpropagation. The result is a network that requires M more binary convolutions than a straightforward binary neural network, but it is expected that these will be significantly more hardware friendly. Experiments on ImageNet show that the approach outperforms competing approaches.
Binary convolutional networks are an important topic with with obvious commercial applications. The idea in the paper is good, and the results on ImageNet are encouraging.
Comments
1. Given that you approximate a real valued convolution with M binary convolutions, it seems to me that the approximate cost would be similar to using M binary CNNs like XNOR nets. With this in mind, I think the approach should really be compared to an ensemble of M XNOR nets trained with different initial weights, both in terms of total train time and prediction accuracy.
2. The paper suggests the v_i shifts are trainable. Why are values for these given in table 4 and the supplementary material. Are these the initial values?
3. The paper uses fixed values for the u_i's but mentions that these could also be trained. Why not train them too? Have you tried this?
4. It's not clear from the paper if solving regression problems for the alphas during training adds much to the train time.
5. It would be nice to have an estimation of the total cost of inference for the approach on a typical net (e.g. ResNet-18) given some realistic assumptions about the hardware, and compare this with other methods (perhaps in the supplementary material)


Generative Local Metric Learning for Kernel Regression
This paper shows how metric learning can be used with Nadaraya-Watson (NW) kernel regression. Compared with standard approaches, such as bandwidth selection, we show how metric learning can significantly reduce the mean square error (MSE) in kernel regression, particularly for high-dimensional data. We propose a method for efficiently learning a good metric function based upon analyzing the performance of the NW estimator for Gaussian-distributed data. A key feature of our approach is that the NW estimator with a learned metric uses information from both the global and local structure of the training data. Theoretical and empirical results confirm that the learned metric can considerably reduce the bias and MSE for kernel regression even when the data are not confined to Gaussian.

Metric learning is one of the fundamental problems in person re-identification. This paper presents a metric learning method using Nadaraya-Watson (NW) kernel regression. The key feature of the work is that the NW estimator with a learned metric uses information from both the global and local structure of the training data. Theoretical and empirical 9 results confirm that the learned metric can considerably reduce the bias and MSE for kernel regression even when the data are not confined to Gaussian.
The main contribution lies in the following aspects:
1.	Provided a formation on how metric learning can be embedded in a kernel regression method.
2.	Proposed and proved a theorem that guarantees the existence of a good metric that can eliminate the leading order bias at any point regardless of assumption of Gaussian distribution of the data.
3.	Under Gaussian model assumption, provided an efficient algorithm that can guarantee to achieve an optimal metric solution for reducing regression error.
Overall, this paper’s reasoning is rigorous. Description is clear. The experiments sufficiently demonstrate the author’s claims for the proposed method.
However, it needs major revision before it is accepted. My comments are as follows:
1. The structure of the paper is confused. I suggest the authors add contributions of the papers in the introduction section. The usage and importance of this paper needs to be further clarified.
2.  I also find some grammar problems in this paper. Author needs to carefully check these mistakes, which is very important for readers.
3. The limitations of the proposed method are scarcely discussed.
4. The works also cannot describe the latest developments since there are too few references after 2016.
5. The authors only show very few experiments results in section 5, I think it is not enough. Except MSE, the authors also should provide other comparisons, such as Root mean squared error of classication accuracy(RMSE) or MSE, etc. In this way, the results of the paper will be more reasonable.


Learning to Model the Tail
We describe an approach to learning from long-tailed, imbalanced datasets that are prevalent in real-world settings. Here, the challenge is to learn accurate "fewshot" models for classes in the tail of the class distribution, for which little data is available. We cast this problem as transfer learning, where knowledge from the data-rich classes in the head of the distribution is transferred to the data-poor classes in the tail. Our key insights are as follows. First, we propose to transfer meta-knowledge about learning-to-learn from the head classes. This knowledge is encoded with a meta-network that operates on the space of model parameters, that is trained to predict many-shot model parameters from few-shot model parameters. Second, we transfer this meta-knowledge in a progressive manner, from classes in the head to the "body", and from the "body" to the tail. That is, we transfer knowledge in a gradual fashion, regularizing meta-networks for few-shot regression with those trained with more training data. This allows our final network to capture a notion of model dynamics, that predicts how model parameters are likely to change as more training data is gradually added. We demonstrate results on image classification datasets (SUN, Places, and ImageNet) tuned for the long-tailed setting, that significantly outperform common heuristics, such as data resampling or reweighting.

Summary
	-------
	The paper proposes an approach for transfer learning for
	multi-class classification problems that aids the learning of categories
	with few training examples (the categories in the tail of the
	distribution of numbers of examples per category). It is based
	on ideas of meta-learning: it builds a (meta-)model of the dynamics
	that accompany the change in model parameters as more training
	data is made available to a classifier.
	Specifically, the proposed approach takes inspiration from
	existing work on meta-learning [20] but extends it by applying
	it to CNNs, utilizing deep residual networks as the
	meta-model, and applying the framework to a general 'long-tail
	problem' setting in which the number of training examples
	available is different and not fixed between categories.
	Experiments are conducted on curated versions of existing
	datasets (curated such that they exhibit strong long-tail
	distributions): SUN-397 [13], Places [7], and ImageNet
	[5]. The performance of the proposed method is demonstrated to
	be considerably higher than several more adhoc baselines from
	the literature.
	Novelty and significance
	------------------------
	While the proposed method draws inspiration from a variety of
	existing methods in transfer learning (notably [20]), the
	particular formulation using deep residual networks as a
	meta-model, modeling the dynamics of adding progressively more
	training examples, and handling the case of different numbers
	of available training examples per category in a unified and
	automatic way are novel aspects of the paper to my knowledge.
	These aspects could potentially be useful to a wider range of
	applications than (image) classification and facilitate the
	treatment of long-tail problems, as they arise in many
	real-world application scenarios.
	Technical correctness
	---------------------
	The proposed method of (meta-)modeling the gradual addition of
	training examples seems plausible and technically correct.
	It would, however, be interesting to learn more about the
	complexity of the proposed approach in terms of training time,
	since a significant number of individual models has to be
	trained prior to training the meta-model.
	Experimental evalution
	----------------------
	The experimental evaluation seems convincing: it is done on
	three different existing datasets, compares the proposed
	approach to existing, more ad-hoc baselines as well as [20],
	and highlights the contributions to performance of the
	different proposed system components (notably, taking the step
	from fixed to recursive splitting of categories). Performance
	is indeed best for the proposed method, but considerable
	margins, and particularly pronounced for tail categories.
	Presentation
	------------
	The paper text seems to suffer from a latex compilation issue
	that results in missing multiple bibliographic and figure
	references (questions marks instead of numbers: line 79, 176,
	239, 277, Tab. 1), which is unfortunate and a possible
	indication that the paper submission has been rushed or a
	premature version uploaded. The text, hoever, does contain
	enough information in order to know what is going on despite
	not having the references.
	The authors should please comment on this and what the correct
	references are in their rebuttal.
	Apart from this issue, the paper is well written and clearly
	presents the proposed ideas, experimental results, and
	relation to prior work.
	Typo line 74: 'changeling' - challenging; line 96: 'the the'


Information Theoretic Properties of Markov Random Fields, and their Algorithmic Applications
Markov random fields are a popular model for high-dimensional probability distributions. Over the years, many mathematical, statistical and algorithmic problems on them have been studied. Until recently, the only known algorithms for provably learning them relied on exhaustive search, correlation decay or various incoherence assumptions. Bresler [4] gave an algorithm for learning general Ising models on bounded degree graphs. His approach was based on a structural result about mutual information in Ising models. Here we take a more conceptual approach to proving lower bounds on the mutual information. Our proof generalizes well beyond Ising models, to arbitrary Markov random fields with higher order interactions. As an application, we obtain algorithms for learning Markov random fields on bounded degree graphs on n nodes with r-order interactions in n r time and log n sample complexity. Our algorithms also extend to various partial observation models.

The setup in Eq. 1 is unclear on a first reading. What is the
	exact meaning of r here? This is a critical constant in the
	major result proven, and not carefully defined anywhere in the
	paper. I *think* that r is the maximum clique size. This is
	particularly ambiguous because of the statement that
	theta^{i1,i2,...,il}(a1,a2,...,an) "is assumed to be zero on
	non-cliques". I've assumed the meaning of this is that, more
	precisely, that function ignores aj unless there is some value
	t such that aj=it. Then, this makes sense as a definition of a
	Markov random field with maximum clique size r. (I encourage
	clarification of this in the paper if correct, and a rebuttal
	if I have misunderstood this.)
	In any case, this is an unusual definition of an MRF in the
	NIPS community. I think the paper would have more impact if a
	more standard definition of an MRF were used in the
	introduction, and then the equivalence/conversion were just
	done in the technical part. The main result only references
	the constant r, so no need to introduce all this just to state
	the result.
	On a related note, it's worth giving a couple sentences on the
	relationship to Bresler's result. (For an Ising model, r=2,
	etc.) In particular, one part of this relationship is a bit
	unclear to me. As far as I know, Bresler's result applies to
	arbitrary Ising models, irrespective of graph structure. So,
	take an Ising model with a dense structure so that there are
	large cliques. In this case, it seems to me that the current
	paper's result will use (r-1) nodes while Bresler's will still
	use a single node-- thus in that particular case the current
	paper's result is weaker. Is this correct? (It's not a huge
	weakness even if true but worth discussing in detail since it
	could guide future work.) [EDIT: I see now that this is *not* the case, see response below]
	I also feel that the discussion of Chow-Liu is missing a very
	important aspect. Chow-Liu doesn't just correctly recover the
	true structure when run on data generated from a tree. Rather,
	Chow-Lui finds the *maximum-likelihood* tree for data from an
	*arbitrary* distribution. This is a property that almost all
	follow-up work does not satisfy (Srebro showed bounds). The
	discussion in this paper is all true, but doesn't mention that
	"maximum likelihood" or "model robustness" issue at all, which
	is hugely important in practice.
	For reference: The basic result is that given a single node $u$,
	and a hypothesized set of "separators" $S$ (neighbors of $u$) then
	there will be some set of nodes $I$ with size at most $r-1$ such
	that $u$ and $I$ have positive conditional mutual information.

	The proof of the central result proceeds by setting up a
	"game", which works as follows:
	1) We pick a node $X_u$ to look at.
	2) Alice draws two joint samples $X$ and $X'$.
	3) Alice draws a random value $R$ (uniformly from the space of
	possible values of $X_u$
	4) Alice picks a random set of neighbors of $X_u$, call them $X_I$.
	5) Alice tells Bob the values of $X_I$
	6) Bob get's to wager on if $X_u=R$ or $X'_u=R$. Bob wins his
	wager if $X_u=R$ an loses his wager if $X'_u=R$ and nothing
	happens if both or neither are true.
	Here I first felt like I *must* be missing something, since
	this is just establishing that $X_u$ has mutual information
	with it's neighbors. (There is no reference to the "separator"
	set S in the main result.) However, it later appears that this
	is just a warmup (regular mutual information) and can be
	extended to the conditional setting.
	Actually, couldn't the conditional setting itself be phrased
	as a game, something like
	1) We pick a node $X_u$ and a set of hypothesized "separators"
	$X_S$ to look at.
	2) Alice draws two joint samples $X$ and $X'$ Both are
	conditioned on the some random value for $X_S$.
	3) Alice draws a random value $R$ (uniformly from the space of
	possible values of $X_u$
	4) Alice picks a random set of nodes (not including $X_u$ or $X_S$, call them $X_I$.
	5) Alice tells Bob the values of $X_I$
	6) Bob get's to wager on if $X_u=R$ or $X'_u=R$. Bob wins his
	wager if $X_u=R$ an loses his wager if $X'_u=R$ and nothing
	happens if both or neither are true.
	I don't think this adds anything to the final result, but is
	an intuition for something closer to the final goal.
	After all this, the paper discusses an algorithm for greedily
	learning an MRF graph (in sort of the obvious way, by
	exploiting the above result) There is some analysis of how
	often you might go wrong estimating mutual information from
	samples, which I appreciate.

	Overall, as far as I can see, the result appears to be
	true. However, I'm not sure that the purely theoretical result
	is sufficiently interesting (at NIPS) to be published with no
	experiments. As I mentioned above, Chow-Liu has the major
	advantage of finding the  maximum likelihood solution, which the current method
	does not appear to have. (It would violate hardness results
	due to Srebro.) Further, note that the bound given in Theorem
	5.1, despite the high order, is only for correctly recovering
	the structure of a single node, so there would need to be
	another lever of applying the union bound to this result with
	lower delta to get a correct full model.
EDIT AFTER REBUTTAL:
Thanks for the rebuttal. I see now that I should understand $r$ not as the maximum clique size, but rather as the maximum order of interactions. (E.g. if one has a fully-connected Ising model, you would have r=2 but the maximum clique size would be n). This answers the question I had about this being a generalization of Bressler's result. (That is, this paper's is a strict generalization.) This does slightly improve my estimation of this paper, though I thought this was a relatively small concern in any case. My more serious concerns are that a pure theoretical result is appropriate for NIPS.


Teaching Machines to Describe Images via Natural Language Feedback
Robots will eventually be part of every household. It is thus critical to enable algorithms to learn from and be guided by non-expert users. In this paper, we bring a human in the loop, and enable a human teacher to give feedback to a learning agent in the form of natural language. We argue that a descriptive sentence can provide a much stronger learning signal than a numeric reward in that it can easily point to where the mistakes are and how to correct them. We focus on the problem of image captioning in which the quality of the output can easily be judged by non-experts. In particular, we first train a captioning model on a subset of images paired with human written captions. We then let the model describe new images and collect human feedback on the generated descriptions. We propose a hierarchical phrase-based captioning model, and design a feedback network that provides reward to the learner by conditioning on the human-provided feedback. We show that by exploiting descriptive feedback on new images our model learns to perform better than when given human written captions on these images.

The paper presents an approach for automatically captioning images where the model also incorporates natural language feedback from humans along with ground truth captions during training. The proposed approach uses reinforcement learning to train a phrase based captioning model where the model is first trained using maximum likelihood training (supervised learning) and then further finetuned using reinforcement learning where the reward is weighted sum of BLEU scores w.r.t to the ground truth and the feedback sentences provided by humans. The reward also consists of phrase level rewards obtained by using the human feedback.
The proposed model is trained and evaluated on MSCOCO image caption data. The proposed model is compared with a pure supervised learning (SL) model, a model trained using reinforcement learning (RL) without any feedback. The proposed model outperforms the pure SL model by a large margin and the RL model by a small margin.
Strengths:
1.	The paper is well motivated with the idea of using human in the loop for training image captioning models.
2.	The baselines (SL and RL) are reasonable and the additional experiment of using 1 GT vs. 1 feedback caption is insightful and interesting.
3.	The work can be great significance especially if the improvements are significantly large over the RL without any feedback baseline.
Weaknesses:
1.	The paper is motivated with using natural language feedback just as humans would provide while teaching a child. However, in addition to natural language feedback, the proposed feedback network also uses three additional pieces of information – which phrase is incorrect, what is the correct phrase, and what is the type of the mistake. Using these additional pieces is more than just natural language feedback. So I would like the authors to be clearer about this in introduction.
2.	The improvements of the proposed model over the RL without feedback model is not so high (row3 vs. row4 in table 6), in fact a bit worse for BLEU-1. So, I would like the authors to verify if the improvements are statistically significant.
3.	How much does the information about incorrect phrase / corrected phrase and the information about the type of the mistake help the feedback network? What is the performance without each of these two types of information and what is the performance with just the natural language feedback?
4.	In figure 1 caption, the paper mentions that in training the feedback network, along with the natural language feedback sentence, the phrase marked as incorrect by the annotator and the corrected phrase is also used. However, from equations 1-4, it is not clear where the information about incorrect phrase and corrected phrase is used. Also L175 and L176 are not clear. What do the authors mean by “as an example”?
5.	L216-217: What is the rationale behind using cross entropy for first (P – floor(t/m)) phrases? How is the performance when using reinforcement algorithm for all phrases?
6.	L222: Why is the official test set of MSCOCO not used for reporting results?
7.	FBN results (table 5): can authors please throw light on why the performance degrades when using the additional information about missing/wrong/redundant?
8.	Table 6: can authors please clarify why the MLEC accuracy using ROUGE-L is so low? Is that a typo?
9.	Can authors discuss the failure cases of the proposed (RLF) network in order to guide future research?
10.	Other errors/typos:
a.	L190: complete -> completed
b.	L201, “We use either … feedback collection”: incorrect phrasing
c.	L218: multiply -> multiple
d.	L235: drop “by”
Post-rebuttal comments:
I agree that proper evaluation is critical. Hence I would like the authors to verify that the baseline results [33] are comparable and the proposed model is adding on top of that.
So, I would like to change my rating to marginally below acceptance threshold.


Compression-aware Training of Deep Networks
In recent years, great progress has been made in a variety of application domains thanks to the development of increasingly deeper neural networks. Unfortunately, the huge number of units of these networks makes them expensive both computationally and memory-wise. To overcome this, exploiting the fact that deep networks are over-parametrized, several compression strategies have been proposed. These methods, however, typically start from a network that has been trained in a standard manner, without considering such a future compression. In this paper, we propose to explicitly account for compression in the training process. To this end, we introduce a regularizer that encourages the parameter matrix of each layer to have low rank during training. We show that accounting for compression during training allows us to learn much more compact, yet at least as effective, models than state-of-the-art compression techniques.
low rank in the training loss, and rely on a stochastic proximal gradient descent strategy to optimize the network parameters. In essence, and by contrast with methods that aim to learn uncorrelated units to prevent overfitting [5,54,40], we seek to learn correlated ones, which can then easily be pruned in a second phase. Our compression-aware training scheme therefore yields networks that are well adapted to the following post-processing stage. As a consequence, we achieve higher compression rates than the above-mentioned techniques at virtually no loss in prediction accuracy.
Our approach constitutes one of the very few attempts at explicitly training a compact network from scratch. In this context, the work of [4] has proposed to learn correlated units by making use of additional noise outputs. This strategy, however, is only guaranteed to have the desired effect for simple networks and has only been demonstrated on relatively shallow architectures. In the contemporary work [51], units are coordinated via a regularizer acting on all pairs of filters within a layer. While effective, exploiting all pairs can quickly become cumbersome in the presence of large numbers of units. Recently, group sparsity has also been employed to obtain compact networks [2,50]. Such a regularizer, however, acts on individual units, without explicitly aiming to model their redundancies. Here, we show that accounting for interactions between the units within a layer allows us to obtain more compact networks. Furthermore, using such a group sparsity prior in conjunction with our compression-aware strategy lets us achieve even higher compression rates.
We demonstrate the benefits of our approach on several deep architectures, including the 8-layers DecomposeMe network of [1] and the 50-layers ResNet of [23]. Our experiments on ImageNet and ICDAR show that we can achieve compression rates of more than 90%, thus hugely reducing the number of required operations at inference time.

The authors present a regularization term that encourages weight matrices to be low rank during network training, effectively increasing the compression of the network, and making it possible to explicitly reduce the rank during post-processing, reducing the number of operations required for inference. Overall the paper seems like a good and well written paper on an interesting topic. I have some caveats however: firstly the authors do not mention variational inference, which also explicitly compresses the network (in the literal sense of reducing the number of bits in its description length) and can be used to prune away many weights after training - see 'Practical Variational Inference for Neural Networks' for details. More generally, almost any regularizer provides a form of implicit 'compression-aware training' (that's why they work - simpler models generalize better) and can often be used to prune networks post-hoc. For example a network trained with l1 or l2 regularization will generally end up with many weights very close to 0, which can be removed without greatly altering network performance. I think it's important to clarify this, especially since the authors use an l2 term in addition to their own regularizer during training. They also don't compare seem to compare how well previous low rank post processing works with and without their regulariser, or with other regularisers used in previous work. All of these caveats could be answered by providing more baseline results in the experimental section, demonstrating that training with this particular regulariser does indeed lead to a better accuracy / compression tradeoff than other approaches.
In general I found the results a little hard to interpret, so may be missing something: the graph I wanted to see was a set of curves for accuracy vs compression ratio (either in terms of number of parameters or number of MACs) rather than accuracy against the strength of the regularisation term.  On this graph it should be possible to explicitly compare your approach vs previous regularisers / compressors.


Multiscale Semi-Markov Dynamics for Intracortical Brain-Computer Interfaces
Intracortical brain-computer interfaces (iBCIs) have allowed people with tetraplegia to control a computer cursor by imagining the movement of their paralyzed arm or hand. State-of-the-art decoders deployed in human iBCIs are derived from a Kalman filter that assumes Markov dynamics on the angle of intended movement, and a unimodal dependence on intended angle for each channel of neural activity. Due to errors made in the decoding of noisy neural data, as a user attempts to move the cursor to a goal, the angle between cursor and goal positions may change rapidly. We propose a dynamic Bayesian network that includes the on-screen goal position as part of its latent state, and thus allows the person's intended angle of movement to be aggregated over a much longer history of neural activity. This multiscale model explicitly captures the relationship between instantaneous angles of motion and long-term goals, and incorporates semi-Markov dynamics for motion trajectories. We also introduce a multimodal likelihood model for recordings of neural populations which can be rapidly calibrated for clinical applications. In offline experiments with recorded neural data, we demonstrate significantly improved prediction of motion directions compared to the Kalman filter. We derive an efficient online inference algorithm, enabling a clinical trial participant with tetraplegia to control a computer cursor with neural activity in real time. The observed kinematics of cursor movement are objectively straighter and smoother than prior iBCI decoding models without loss of responsiveness.

The paper describes a novel brain-computer-interface algorithm for controlling movement of a cursor to random locations on a screen using neuronal activity (power in the "spike-spectrum" of intra-cortically implanted selected electrodes).
The algorithm uses a dynamic Bayesian network model that encodes possible target location (from a set of possible positions on a 40x40 grid, layed out on the screed). Target changes can only occur once a countdown timer reaches zero (time intervals are drawn at random) at which time the target has a chance of switching location. This forces slow target location dynamics.
Observations (power in spike spectrum) are assumed to be drawn from a multi modal distribution (mixture of von Mises functions) as multiple neurons may affect the power recording on a single electrode and are dependent on the current movement direction. The position is simply the integration over time of the movement direction variable (with a bit of decay).
The novel method is compared with several variations of a Kalman filter (using same movement state space but missing the latent target location) and an HMM. Experiments are performed off line (using data from closed loop BCI session using either a Kalman filter or an HMM) and also in 2 online closed-loop sessions (alternating between Kalman filter and the new method). Experiments performed an a tetraplegic human subject.
Overall the paper (sans supplementary material with is essential to understanding the experiment) is well written. The new model vastly outperforms the standard Kalman Filter, as is clear from the multiple figures and supplementary movies (!).
Some comments:
- I gather that the von Mieses distribution was used both for modelling the observations given the intended movement direction and for modelling the next goal position. I found the mathematical description of the selection of the goal position unclear. Is there a distribution over possible goal positions or is a single goal position selected at each time point during inference? Can you clarify?
- Once a timer is set, can the goal be changed before the timer expires? My understanding is that it cannot, no matter what the observations show. I find this to be a strange constraint. There should be more straightforward ways of inducing slow switch rates that would not force the estimate of the target position to stay fixed as new evidence accumulates. e.g. forced transition rates or state cascades.
- My understanding is that the model has no momentum. I.e., the cursor can "turn on a dime". most objects we control can not (e.g hand movements). Would it not make more sense to use a model that preserves some of the velocity and controls some of the accelleration? It is known that some neurons in motor cortex are direction sensitive and other are force sensitive. Would it not be more natural?
- After an initial model learning period, the model is fixed for the rest of the session. It would be interesting to see how the level of performance changes as time passes. Is the level of performance maintained? Is there some degredation as the network / recordings drift? Is there some improvement as the subject masters control of the system? Would an adaptive system perform better? These questions are not addressed.
- The paper is geared at an engineering solution to the BCI problem. There is no attempt at providing insights into what the brain encodes most naturally or how the subject (and neural system) adapt / learn to make the most out of the provided BCI.
- citations are in the wrong format should be numerical [1] , [1-4] etc... not Author et al (2015).


Inhomogeneous Hypergraph Clustering with Applications
Hypergraph partitioning is an important problem in machine learning, computer vision and network analytics. A widely used method for hypergraph partitioning relies on minimizing a normalized sum of the costs of partitioning hyperedges across clusters. Algorithmic solutions based on this approach assume that different partitions of a hyperedge incur the same cost. However, this assumption fails to leverage the fact that different subsets of vertices within the same hyperedge may have different structural importance. We hence propose a new hypergraph clustering technique, termed inhomogeneous hypergraph partitioning, which assigns different costs to different hyperedge cuts. We prove that inhomogeneous partitioning produces a quadratic approximation to the optimal solution if the inhomogeneous costs satisfy submodularity constraints. Moreover, we demonstrate that inhomogenous partitioning offers significant performance improvements in applications such as structure learning of rankings, subspace segmentation and motif clustering.

In this paper the authors consider a novel version of hypergraph clustering. Essentially, the novelty of the formulation is the following: the cost of a cut hyperedge depends on which nodes go on each side of the cut. This is quantified by a weight function over all possible subsets of nodes for each hyperedge. The complexity of such formulation may at first glance seem unnecessary, but the authors illustrate real-world applications where it makes sense to use their formulation. The paper is nicely written. My main critique is that some key ideas of the paper -as the authors point out themselves- are heavily based on [11].
Also some theoretical contributions are weak, both from a technical perspective and with respect to their generality. For instance, Theorem 3.1 is not hard to prove, and is true under certain conditions that may not hold. On the positive side, the authors do a good work with respect to analyzing the shortcomings of their method.Also, the experimental results are convincing to some extent.
My comments follow:
1. The authors provide a motivational example in the introduction. I suggest that the caption under figure  1 should be significantly shortened. The authors may refer the reader to Section 1 for details instead.
2. The authors should discuss in greater details hypergraph clustering, and specifically the formulation where we pay 1 for each edge cut. Τhere is no canonical matrix representation of hypergraphs, and optimizing over tensors is  NP-hard. The authors should check the paper "Hypergraph Markov Operators, Eigenvalues and Approximation Algorithms" by Anand Louis (arxiv:1408.2425)
3.  As pointed out by [21] there is a random walk interpretation for motif-clustering. Is there a natural random walk interpretation of the current formulation in the context of motif clustering?
4.  The experimental results are convincing to some extent. It would have been nicer to see more results on motif-clustering. Is there a class of motifs and graphs where your method may significantly outperform existing methods [10,21]?
Finally, there is a typo in the title, and couple of others (e.g., "is guaranteed to find a constant-approximation solutions"->"is guaranteed to find a constant-approximation solution") along the way. Use ispell or some other similar program to detect all typos, and correct them.


Effective Parallelisation for Machine Learning
We present a novel parallelisation scheme that simplifies the adaptation of learning algorithms to growing amounts of data as well as growing needs for accurate and confident predictions in critical applications. In contrast to other parallelisation techniques, it can be applied to a broad class of learning algorithms without further mathematical derivations and without writing dedicated code, while at the same time maintaining theoretical performance guarantees. Moreover, our parallelisation scheme is able to reduce the runtime of many learning algorithms to polylogarithmic time on quasi-polynomially many processing units. This is a significant step towards a general answer to an open question on the efficient parallelisation of machine learning algorithms in the sense of Nick's Class (NC). The cost of this parallelisation is in the form of a larger sample complexity. Our empirical study confirms the potential of our parallelisation scheme with fixed numbers of processors and instances in realistic application scenarios.

The authors have presented a parallelization algorithm for aggregating weak learners based on Radon partitioning. They present theoretical analysis to motivate the algorithm along with empirical results to support the theory. The theoretical analysis is interesting, and the empirical results demonstrate training time and/or AUC improvements over multiple baseline algorithms, on multiple datasets. The authors also preemptively and convincingly address several questions/concerns in the Evaluation and Discussion sections. I recommend acceptance.
Specific Notes
--------------
- Line 51: "the the" -> "the"
- Line 79: Is this the same size math font as elsewhere? It seems small and kind of hard to read.
- Figures 1-3: The text really needs to be bigger in the figure images.
- Figure 3: This one may be harder to distinguish if printed in black and white.
- Lines 318-320: "the Radon machine outperforms the averaging baseline..." To clarify, is this based on an average of paired comparisons?
- Line 324: A pet peeve of mine is the use of the word significant in papers when not referring to statistical significance results.
- Lines 340-341: Missing some spaces - "machineachieved", and "machineis."
- Lines 341-349: The difference in performance with the AverageAtTheEnd method doesn't seem terribly meaningful. Why wasn't this result included somewhere in Figure 1? Can you advocate more for your method here?
- Line 377: "Long and servedio [22]" The use of author names here seems inconsistent with citations elsewhere (even immediately following).


Online Dynamic Programming
We consider the problem of repeatedly solving a variant of the same dynamic programming problem in successive trials. An instance of the type of problems we consider is to find a good binary search tree in a changing environment. At the beginning of each trial, the learner probabilistically chooses a tree with the n keys at the internal nodes and the n + 1 gaps between keys at the leaves. The learner is then told the frequencies of the keys and gaps and is charged by the average search cost for the chosen tree. The problem is online because the frequencies can change between trials. The goal is to develop algorithms with the property that their total average search cost (loss) in all trials is close to the total loss of the best tree chosen in hindsight for all trials. The challenge, of course, is that the algorithm has to deal with exponential number of trees. We develop a general methodology for tackling such problems for a wide class of dynamic programming algorithms. Our framework allows us to extend online learning algorithms like Hedge [16] and Component Hedge [25] to a significantly wider class of combinatorial objects than was possible before.

The aim of this paper is to extend results in online combinatorial optimization to new combinatorial objects such as $k$-multipaths and binary search trees. Specifically, the authors are interested in extending Expanded-Hedge (EH) and Component Hedge (CH) to online combinatorial games, for which the offline problem can be solved in a bottom-up way using Dynamic Programming.
Though the results about online optimization with $k$-multipaths are interesting, the overall paper could benefit from more polishing: some definitions and notations are not clearly defined, and some assertions look incorrect. Namely:
In Section 4, the set (of subsets) $\mathcal H_v$ is not clearly defined, so it is very difficult for the reader to capture the family of DP tasks defined according to the recurrence relation (3). In this section, some concrete examples of online optimization problems characterized by this DP family would be helpful.
In Section 5, the notion of Binary Search Tree should be clearly defined. Notably, if the authors are interested by the set of all rooted binary trees with $n + 1$ leaves, the cardinality of this set is indeed the Catalan number of order $n$ (as indicated in Line 268). But, contrary to what is claimed in Lines 250-251, there is a well-known characterization of the polytope specified by the convex hull of all rooted binary trees of order $n$: this is the $n$th dimensional associahedron.  Since this polytope is integral, we can use (at least theoretically) the Component Hedge algorithm for projecting points onto this polytope, and decomposing them (by Caratheodory's theorem) into convex combinations of binary trees.
Section 5.2 is of particular importance, as it explains how the online BST problem can be solved using previous results obtained for $k$-multipaths. But the translation of this problem into an online $2$-multipath learning task is not clear at all. To this very point, it is important to explain in unambiguous terms how we can learn BSTs using the CH (or EH) technique used for $k$-multipaths. According to the sets $V$, $\Omega$, and $F_{ij}$ defined in Lines 265-266, are we guaranteed that (i) every $k$-multipath of the induced graph encodes a rooted binary tree with $n+1$ leaves (correctness), and (ii) every possible rooted binary tree with $n+1$ leaves can be encoded by a $k$-multipath of this induced graph?


Reconstruct & Crush Network
This article introduces an energy-based model that is adversarial regarding data: it minimizes the energy for a given data distribution (the positive samples) while maximizing the energy for another given data distribution (the negative or unlabeled samples). The model is especially instantiated with autoencoders where the energy, represented by the reconstruction error, provides a general distance measure for unknown data. The resulting neural network thus learns to reconstruct data from the first distribution while crushing data from the second distribution. This solution can handle different problems such as Positive and Unlabeled (PU) learning or covariate shift, especially with imbalanced data. Using autoencoders allows handling a large variety of data, such as images, text or even dialogues. Our experiments show the flexibility of the proposed approach in dealing with different types of data in different settings: images with CIFAR-10 and CIFAR-100 (not-in-training setting), text with Amazon reviews (PU learning) and dialogues with Facebook bAbI (next response classification and dialogue completion).

The paper proposes a classification technique using deep nets to deal with:
(a) covariate shift (i.e., when the train and test data do not share the same distribution)
(b) PU settings (i.e., when there are only positive and unlabeled datapoints are available).
The key idea is to train an auto-encoder that reconstruct the positive instances with small error and the remaining instances (negative or unlabeled) with a large error (above a desired threshold). This structure forces the network to learn patterns that are intrinsic to the positive class (as opposed to features that are discriminative across different classes). The experiments highlight that the proposed method outperforms baselines across different tasks with different data types (image, short text, and dialogues).
Overall, I enjoyed reading the paper. It is honest, concise and well-written. The idea of considering the reconstruction error of auto-encoders as an energy function is indeed interesting. While my overall recommendation is accept, there are a few points that I am not confident about:
(1) The baselines; For the image classification experiments, the authors use a standard CNN as a baseline and I'm not quite certain if these count as a competitive baseline (specially for the "not-in-training" setup). My question is that are there other baselines that are more suitable for such settings?
(2) The design of auto-encoders are discussed only briefly. The suggested structures are not trivial (e.g., (32)3c1s-(32)3c1s-(64)3c2s-(64)3c2-(32)3c1s-512f-1024f). The only discussion on the structure is the following sentence: "The choice of architectures for standard classifier and auto-encoder is driven by necessity of fair comparison." which is frankly not sufficient. At the same time, It seems to me this is the general trend in research on Neural Nets. Thus, I'm not confident how much this concern is valid.
Overall, my recommendation is accept however with not so great confidence in my review.


Structured Generative Adversarial Networks
We study the problem of conditional generative modeling based on designated semantics or structures. Existing models that build conditional generators either require massive labeled instances as supervision or are unable to accurately control the semantics of generated samples. We propose structured generative adversarial networks (SGANs) for semi-supervised conditional generative modeling. SGAN assumes the data x is generated conditioned on two independent latent variables: y that encodes the designated semantics, and z that contains other factors of variation. To ensure disentangled semantics in y and z, SGAN builds two collaborative games in the hidden space to minimize the reconstruction error of y and z, respectively. Training SGAN also involves solving two adversarial games that have their equilibrium concentrating at the true joint data distributions p(x, z) and p(x, y), avoiding distributing the probability mass diffusely over data space that MLE-based methods may suffer. We assess SGAN by evaluating its trained networks, and its performance on downstream tasks. We show that SGAN delivers a highly controllable generator, and disentangled representations; it also establishes start-of-the-art results across multiple datasets when applied for semi-supervised image classification (1.27%, 5.73%, 17.26% error rates on MNIST, SVHN and CIFAR-10 using 50, 1000 and 4000 labels, respectively). Benefiting from the separate modeling of y and z, SGAN can generate images with high visual quality and strictly following the designated semantic, and can be extended to a wide spectrum of applications, such as style transfer.

Summary:
This paper proposes a novel GAN structure for semi-supervised learning, a setting in which there exist a small dataset with class labels along with a larger unlabeled dataset. The main idea of this paper is to disentangle the labels (y) from the hidden states (z) using two GAN problems that represent p(x,y) and p(x,z). The generator is shared between both GAN problems, but each problem is trained simultaneously using ALI[4]. There are two adversarial games defined for training the joints p(x, y) and p(x, z). Two "collaborative games" are also defined in order to better disentangle y from z and enforce structure on y.
Pros:
1) Overall, the paper is written well. All the steps are motivated intuitively. The presented ideas look rational.
2) The presented results on the semi-supervised learning task (Table 2) are very impressive. The proposed method outperforms previous GAN and VAE works. The qualitative results in terms of generative samples look very interesting.
Cons:
1) I found the mutual predictability measure very ad-hoc. There exist other measures such as mutual information that have been used in past (e.g. infoGAN) for measuring disentanglability of DGMs.
2) The collaborative games presented in Eq.4 and Eq.5 is equivalent to the mutual information term introduced in infoGAN[2] (with \lambda=1).
In this case, the paper can be considered as the combination of infoGAN and ALI applied to semi-supervised learning. This slightly limits the technical novelty of the paper.
Questions:
1) I am wondering why the adversarial game L_{xy} is only formed on the labeled set X_l. A similar game could be created on the unlabeled set. The only difference would be that instead of labels, one would use y=C(x) for the first term in Eq.3. However in this paper, instead, a collaborative game R_y is introduced.
2) Theorem 3.3 does not state whether minimizing R_z or R_y w.r.t G will change the equilibrium of the adversarial game or not. In other words, with minimization over G in both Eq.4 and Eq.5, can we still guarantee that G will match the data distribution.
Minor comments:
1) line 110: Goodfellow et al is missing the reference.
2) line 197: Is l-2 distance resulted from assuming a normal prior on z?
3) line 213: p_g(z|y)  --> p_g(x|y)
4) With all the different components (p, p_g, p_c, etc) it is a bit challenging to follow the structure of adversarial and collaborative games. A figure would help readers to follow the logic of the paper easier.


Adaptive Batch Size for Safe Policy Gradients
Policy gradient methods are among the best Reinforcement Learning (RL) techniques to solve complex control problems. In real-world RL applications, it is common to have a good initial policy whose performance needs to be improved and it may not be acceptable to try bad policies during the learning process. Although several methods for choosing the step size exist, research paid less attention to determine the batch size, that is the number of samples used to estimate the gradient direction for each update of the policy parameters. In this paper, we propose a set of methods to jointly optimize the step and the batch sizes that guarantee (with high probability) to improve the policy performance after each update. Besides providing theoretical guarantees, we show numerical simulations to analyse the behaviour of our methods.

Summary:
This paper derives conditions for guaranteed improvement when using policy gradient methods. These conditions are for stochastic gradient estimates and also bound the amount of improvement with high probability. The authors then show how these bounds can be optimized by properly selecting the step size and batch size parameters. This is in contrast to previous work that only considers how the step size can be optimized. The result is an algorithm that can guarantee improvement with high probability.
Note: I did not verify all of the math, but at an intuitive level the theorems and lemmas in the main body are believable.
Major:
1. What am I supposed to take away from this paper? Am I supposed to think "I should use policy gradient methods with their safe step size & batch size approach if I need a safe RL algorithm"? Or, am I supposed to think "This paper is presenting some interesting theoretical insights into how step sizes and batch sizes impact policy gradient methods"?
If the answer is the former, then the results are abysmally bad. The axes are all scaled by 10^7 trajectories. Even the fastest learning methods are therefore impractically slow. This doesn't appear to be a practical algorithm. Compare to the results in your reference [23], where high confidence improvement is achieved using hundreds to thousands of episodes. So, the proposed algorithm does not appear to be practical or competitive as a practical method.
This makes me think that the contribution is the latter: a theoretical discussion about step sizes, batch sizes, and how they relate to guaranteed improvement. This is interesting and I would recommend acceptance if this was the pitch of the paper. However, this is not made clear in the introduction. Until I reached the empirical results I thought that the authors were proposing a practical algorithm. I propose that the introduction should be modified to make it clear what the contribution is: are you presenting theoretical results (e.g., like a PAC RL paper), or are you proposing a practical algorithm? If the answer is the latter, then you need to compare to existing works or explain why it is not an issue that your method requires so much data.
2. The assumption that the policy is Gaussian is crippling. In many of the real-world applications of RL (e.g., dialogue systems) the actions are discrete, and so the policy is not Gaussian. Does this extend to other policy forms, like softmax policies? Is this extension straightforward, or are there additional challenges?
Medium:
1. Line 92. You say that convergence is assured because the angular difference is at most \pi/2. A similar claim was made by Peters and Schaal in their natural actor-critic paper, and it later turned out to be false (See "GeNGA: A generalization of natural gradient ascent with positive and negative convergence results" by Thomas at ICML 2014). Your claim is different from Peters and Schaal's, but due to the history of these off-hand claims tending to be false, you should provide a proof or a reference for this claim.
2. You use concentration bounds that tend to be wildly over-conservative (Chebyshev & Hoeffding) because they must hold for a broad class of distributions. This is obviously the correct first step. However, have you considered using bounds that are far tighter (but make false distributional assumptions), like Student's t-test? If the gradient estimate is the mean of n i.i.d gradient estimates, then by the Central Limit Theorem the gradient estimate is approximately normally distributed, and so Student's t-test is reasonable. Empirically, does it tend to result in improvements with high probability while requiring far less data? It seems like a practical implementation should not use Hoeffding / Chebyshev / Bernstein...
3. Page 7 is one log paragraph.
Minor:
1. Line 74 "paramters"
2. Capitalization in section titles is inconsistent (e.g., section 3 capitalizes Policies but not Size or Scalar).
3. Line 91 "but, being the \alpha_i non-negative". Grammar error here.
4. Integrals look better with a slight space before the dx terms: $$\int_{\mathcal X} f(x) \, \mbox{d}x$$. The $\,$ here helps split the terms visually.
5. Line 102 "bound requires to compute" - requires who or what to compute something? Grammar.
6. The line split on line 111 is awkward.
7. Equation below 113, use \text{} for "if" and "otherwise".
8. Below 131, $\widehat$ looks better on the $\nabla$ symbol, and use $\max$ for max.
9. Line 140 say what you mean by the "optimal step size" using an equation.
10. Line 192, don't use contractions in technical writing (i.e., don't write "doesn't", write "does not").
AFTER AUTHOR REBUTTAL:
My overall review has not changed. I've increased to accept (7 from 6) since the authors are not claiming that they are presenting a practical algorithm, but rather presenting interesting theoretical results.


Concrete Dropout
Dropout is used as a practical tool to obtain uncertainty estimates in large vision models and reinforcement learning (RL) tasks. But to obtain well-calibrated uncertainty estimates, a grid-search over the dropout probabilities is necessarya prohibitive operation with large models, and an impossible one with RL. We propose a new dropout variant which gives improved performance and better calibrated uncertainties. Relying on recent developments in Bayesian deep learning, we use a continuous relaxation of dropout's discrete masks. Together with a principled optimisation objective, this allows for automatic tuning of the dropout probability in large models, and as a result faster experimentation cycles. In RL this allows the agent to adapt its uncertainty dynamically as more data is observed. We analyse the proposed variant extensively on a range of tasks, and give insights into common practice in the field where larger dropout probabilities are often used in deeper model layers.

This paper proposes an approach for automatic tuning of dropout
probabilities under the variational interpretation of dropout as a Bayesian approximation. Since the dropout probability characterizes the overall
posterior uncertainty, such tuning is necessary for calibrated inferences,
but has thus far required expensive manual tuning, e.g., via offline grid
search. The proposed method replaces the fixed Bernoulli variational distribution
at training time with a concrete/gumbel-softmax distribution, allowing use of the
reparameterization trick to compute low-variance stochastic gradients
of the ELBO wrt dropout probabilities. This is evaluated on a range of tasks
ranging from toy synthetic datasets to capturing uncertainty in semantic
segmentation and model-based RL.
The motivation seems clear and the proposed solution is simple and
natural, combining dropout Bayesian inference with the concrete
distribution in the obvious way. The technical contributions of the
paper seem relatively minimal, but this is not necessarily a problem;
it's great when a simple, straightforward method turns out to
give impressive results.
That said, given the straightforwardness of the approach, the
significance of this paper rests heavily on the evaluation, and here I
am not really convinced. Although there are a lot of experiments, none
seems to show a compelling advantage and collectively they fail to
answer many natural questions about the approach. For example:
 - what is the training time overhead versus standard dropout? (line
   281 says 'negligible' but this is never quantified, naively I'd
   expect differentiating through the gumbel-softmax to add
   significant overhead)
 - do the learned dropout probabilities match the (presumably optimal)
   probabilities obtained via grid search?
 - how to set the temperature of the concrete distribution (and does
   this matter)? The code in the appendix seems to used a fixed t=0.1
   but this is never mentioned or discussed in the paper.
 - how does this method compare to other reasonable baselines, eg
   explicit mean-field BNNs, or Gaussian dropout with tuned alpha? The
   latter seems like a highly relevant comparison, since the Gaussian
   approach seems simpler both theoretically and in implementation (is
   directly reparameterizable without the concrete approximation), and
   to dismiss it by reference to a brief workshop paper [28] claiming
   the approach 'underperforms' (I don't see such a conclusion in
   that paper even for the tasks it considers, let alone in any
   more general sense) is lazy.
 - there is a fair amount of sloppiness in the writing, including
   multiple typos and cases where text and figures don't agree (some
   detailed below). This does not build confidence in the
   meticulousness of the experiments.
More specific comments:
Synthetic data (sec 4.1): I am not sure what
to conclude from this experiment. It reads as simply presenting the
behavior of the proposed approach, without any critical evaluation of
whether that behavior is good. Eg, Fig 1b describes aleatoric
uncertainty as following an 'increasing trend' (a bit of a stretch
given that the majority of steps are decreasing), and 1c describes
predictive uncertainty as 'mostly constant' (though the overall shape
actually looks very similar to 1b) -- but why is it obvious that
either of these behaviors is correct or desirable? Even if this
behavior qualitatively matches what you'd get from a more principled
Bayesian approach (I was expecting the paper to argue this but it
doesn't), a simple synthetic task should be an opportunity for a real
quantitative comparison: how closely do the dropout uncertainties
match what you'd get from, e.g., HMC, or even exact
Bayesian linear regression (feasible here since the true function is
linear -- so concrete dropout on a linear model should be a fair
comparison).
UCI (sec 4.2): the experimental setup is not clear to me -- is the
'dropout' baseline using some fixed probability (in which case, what
is it?) or is it tuned by grid search (how?). More fundamentally,
given that the goal of CDropout is to produce calibrated uncertainties,
why are its NLL scores (fig 2, a reasonable measure of uncertainty)
*worse* than standard dropout in the majority of cases?
MNIST (sec 4.3): again no real comparison to other approaches, no
evaluation of uncertainty quality. The accuracy 'matches' hand-tuned
dropout -- does it find the same probabilities? If so this is worth
saying. If not, seems strange to refer to the converged probabilities
as 'optimal' and analyze them for insights.
Computer vision (sec 4.4): this is to me the most promising
experiment, showing that concrete dropout matches or slightly beats
hand-tuned dropout on a real task. It's especially nice to see that
the learned probabilities are robust to initialization since this is a
natural worry in non-convex optimization. Some things that seem
confusing here:
 - what is the metric "IoU"? presumably Intersection over Union but
   this is never spelled out or explained.
 - the differences in calibration between methods are
   relatively small compared to the overall miscalibration of all the
   methods - why is this?
 - text says "middle layers are largely deterministic" which seems
   inconsistent with Fig 8c showing convergence to around p=0.2?
(nitpick: "Table" 2 is actually a figure)
Model-based RL (sec 4.5): It's nice that the model matches our
intuition that dynamics uncertainty should decrease with
experience. But it sounds like this tuning doesn't actually improve
performance (only matches the cumulative reward of a fixed 0.1
dropout), so what's the point? Presumably there should be some
advantages to better-calibrated dynamics uncertainty; why do they not
show up in this task?
The method proposed in this paper seems promising and potentially
quite useful. If so it should be possible to put together a careful
and clear evaluation showing compelling advantages (and minor costs)
over relevant baselines. I'd like to read that paper! But as currently
submitted I don't think this meets the NIPS bar.
UPDATE: increasing my rating slightly post rebuttal. I still think this paper is marginal, but the clarifications promised in the rebuttal (describing the tuning of dropout baselines, and the problems with Gaussian dropout, among others) will make it stronger. It's worth noting that recent work (Molchanov et al., ICML 2017 https://arxiv.org/abs/1701.05369) claims to fix the variance and degeneracy issues with Gaussian dropout; this would be an interesting comparison for future work.


Subspace Clustering via Tangent Cones
Given samples lying on any of a number of subspaces, subspace clustering is the task of grouping the samples based on the their corresponding subspaces. Many subspace clustering methods operate by assigning a measure of affinity to each pair of points and feeding these affinities into a graph clustering algorithm. This paper proposes a new paradigm for subspace clustering that computes affinities based on the corresponding conic geometry. The proposed conic subspace clustering (CSC) approach considers the convex hull of a collection of normalized data points and the corresponding tangent cones. The union of subspaces underlying the data imposes a strong association between the tangent cone at a sample x and the original subspace containing x. In addition to describing this novel geometric perspective, this paper provides a practical algorithm for subspace clustering that leverages this perspective, where a tangent cone membership test is used to estimate the affinities. This algorithm is accompanied with deterministic and stochastic guarantees on the properties of the learned affinity matrix, on the true and false positive rates and spread, which directly translate into the overall clustering accuracy.

Summary:
The paper describes a new geometric insight and a new algorithm for noiseless subspace clustering based on a geometric insight about the tangent cone.
The key idea (Proposition 2) is that if x and x’ are from the same subspace, then -x -\sign(< x,x’ >) \beta x’ should within a union of non-convex cones that comes directly from x and the underlying union of subspaces for all positive \beta, while if x and x’ are not from the same subspace, then when \beta is sufficiently large then the vector will not be on this union of non-convex cones.
The authors then propose an algorithm that tests every ordered pair of observed data points with a similar condition for a crude approximation of the ``union of non-convex cones’’ of interest ---- on the conic hull (therefore convex) of the observed data points.  The algorithm is parameterized by a tuning parameter \beta.  The authors then provide geometric conditions under which:  (1). if \beta is sufficiently large then there are no false positives. (2) if \beta is sufficiently small, then the true positive rate is at least a fixed fraction.  The geometric conditions are different for (1) and (2). For (1) the condition is reasonable, but for (2) it is quite restrictive, as I will explain later.
In addition, the authors analyzed the method under semi-random model (uniform observations on each subspace, or uniformly random subspaces themselves ) and described how to control the true positive rate.
Evaluation:
The paper is well-written.
The technical results appear to be correct (didn’t have time to check the proofs in details). The idea of testing the “affinity” of pairs of data points using tangent cone is new as far as I know. The true positive rate control in Section 4 is new and useful.
The result itself (in Section 4 and 5) seems quite preliminary are has a number of issues.
In particular, it is not clear under what condition there exists a \beta that simultaneously satisfy conditions in Theorem 4 and Theorem 7. Or rather that the largest \rho one can hope to get when we require \beta > \beta_L, and how that number depends on parameters of the stochastic model.
On the other hand, the proposed approach does not seem to solve a larger class of problems than known before through using SSC.  Specifically, SSC allows the number of subspaces to be exponential in the ambient dimension, while the current approach seems to require the sum of dimensions of all subspaces to be smaller than the ambient dimension n. This is critical and not an artifact of the proof because in that case, the tangent cone would be R^n (or is it a half space?).  (For example, consider three 1D disjoint subspaces in 2D).
Part of the motivation of the work is to alleviate the ``graph connectivity’’ problem that SSC suffers.
I believe the authors are not aware of the more recent discoveries on this front.  This issue is effectively solved the noiseless subspace clustering problem with great generality [a].  Now we know that if SSC provides no false discoveries then there is a post processing approach that provides the correct clustering despite potentially disconnected graph for data points in the subspace. The observation was also extended to noisy SSC. The implication of this to the current paper  (which also construct an affinity graph) is that as long as there are no false discoveries and at least d true discoveries (d is the subspace dimension) then the correct clustering can be obtained. Some discussions of the advantage of the proposed approach to the robust post-processing approach described in [a].
Lastly, since the proposed method is based on a seemingly very unstable geometric condition, I feel that it is much more important to analyze the robustness to stochastic noise as in [b,15] and adversarial perturbation as in [a,b].
Overall, I feel that this paper contains enough interesting new insights that should merit an accept to NIPS.
Detailed comments/pointers and references:
1. Noiseless subspace clustering is, in great generality, a solved problem.
-	For l1 SSC, there is a postprocessing approach that provides perfect clustering under only identifiability condition as long as there is no false positives.
-	In other word, on noiseless subspace clustering problem, SSC does not suffer from the graph connectivity problem at all.
-	As a result, the authors should explicitly compare the geometric condition used in this paper to the condition for SSC to yield no-false discoveries [14].
2. Even those geometric conditions in [14] can be removed if we allow algorithms exponential in subspace dimension d (and polynomial in everything else). In fact, L0 verson of SSC can already achieve that solve all subspace clustering problems that are identifiable [a].
3. The noisy subspace clustering and missing data subspace clustering problems are where many of the remaining open problems are. So it will be great if the authors can continue to pursue the new tangent cone idea and figure out how they can solve the noisy/missing data problems in comparison to those approaches existing in the literature.
[a] Wang, Yining, Yu-Xiang Wang, and Aarti Singh. "Graph connectivity in noisy sparse subspace clustering." Artificial Intelligence and Statistics. 2016.
[b] Wang, Yu-Xiang, and Huan Xu. "Noisy Sparse Subspace Clustering." Proceedings of the 30th International Conference on Machine Learning (ICML-13). 2013.