Provable Efficient Online Matrix Completion via Non-convex Stochastic Gradient Descent
Matrix completion, where we wish to recover a low rank matrix by observing a few entries from it, is a widely studied problem in both theory and practice with wide applications. Most of the provable algorithms so far on this problem have been restricted to the offline setting where they provide an estimate of the unknown matrix using all observations simultaneously. However, in many applications, the online version, where we observe one entry at a time and dynamically update our estimate, is more appealing. While existing algorithms are efficient for the offline setting, they could be highly inefficient for the online setting. In this paper, we propose the first provable, efficient online algorithm for matrix completion. Our algorithm starts from an initial estimate of the matrix and then performs non-convex stochastic gradient descent (SGD). After every observation, it performs a fast update involving only one row of two tall matrices, giving near linear total runtime. Our algorithm can be naturally used in the offline setting as well, where it gives competitive sample complexity and runtime to state of the art algorithms. Our proofs introduce a general framework to show that SGD updates tend to stay away from saddle surfaces and could be of broader interests to other non-convex problems.
The paper studies a stochastic gradient descent algorithm for the problem of matrix completion. With a good initialization, it is guaranteed to converge to the true matrix with a geometric rate under standard assumptions. The algorithm is simple and easy to implement. The authors also make efforts to sketch the high-level idea for the proof.
The main contribution in this work is showing that in the context of matrix completion, when equipped with a good initialization, the sequence of the solutions produced by a widely used (but without theoretical guarantee) SGD algorithm converges linearly to the true matrix. The paper reads well and most of theoretical result looks sound. But I have some concerns as follows.  - To guarantee a good initial solution, it (Theorem 3.1) requires a sample complexity "O(mu * d * k^2 * log(d))", which is of the same order as the batch solvers. Is it possible to access fewer samples, e.g., "O(mu * d * k * log(d))" while still ensuring global convergence?  - The vanishing probability of success with respect to iteration counter is strange (it does not conform the intuition). Theorem 3.1 says "for any fixed T >= 1, with probability at least 1 - T/(d^10), we have linear convergence". That means, if we run the algorithm (i.e., repeatedly reveal the samples) for a longer time, we have a LOWER confidence to obtain the true matrix. For example, picking "T = 0.9 * d^10", then we are just guaranteed to obtain convergent solutions with probability at least "10%". If we pick "T" much larger, say "T = O(d^20)", it is not clear whether the algorithm succeeds. However, in practice, one should expect that if the algorithm continues to update the solution, asymptotically, the optimum is obtained.  ---------------------------- Updates:  I slightly increase my score on "technical quality" from "2" to "3", given the considerable amount of work involved. I believe the techniques here are interesting to the community, and many people will pick it up. Yet, it would be grateful if the authors could present a more careful proof technique to get rid of the dependency of "T", or comment on that "T" is always very small.  A minor comment: It appears that another parallel work [A] also studies alternating minimization in online setting. It would be grateful if the authors could comment on the difference.  [A] Fast Algorithms for Robust PCA via Gradient Descent, arXiv:1605.07784