Abstract
This paper considers the problem of solving systems of quadratic equations, namely, recovering an object of interest from m quadratic equations/samples . This problem, also dubbed as phase retrieval, spans multiple domains including physical sciences and machine learning.
We investigate the efficacy of gradient descent (or Wirtinger flow) designed for the nonconvex least squares problem. We prove that under Gaussian designs, gradient descent — when randomly initialized — yields an ϵ-accurate solution in O(log n + log(1/ϵ)) iterations given nearly minimal samples, thus achieving near-optimal computational and sample complexities at once. This provides the first global convergence guarantee concerning vanilla gradient descent for phase retrieval, without the need of (i) carefully-designed initialization, (ii) sample splitting, or (iii) sophisticated saddle-point escaping schemes. All of these are achieved by exploiting the statistical models in analyzing optimization algorithms, via a leave-one-out approach that enables the decoupling of certain statistical dependency between the gradient descent iterates and the data.
1. Introduction
Suppose we are interested in learning an unknown object , but only have access to a few quadratic equations of the form
| (1) |
where yi is the sample we collect and ai is the design vector known a priori. Is it feasible to reconstruct x♮ in an accurate and efficient manner?
The problem of solving systems of quadratic equations (1) is of fundamental importance and finds applications in numerous contexts. Perhaps one of the best-known applications is the so-called phase retrieval problem arising in physical sciences [CESV13,SEC+15]. In X-ray crystallography, due to the ultra-high frequency of the X-rays, the optical sensors and detectors are incapable of recording the phases of the diffractive waves; rather, only intensity measurements are collected. The phase retrieval problem comes down to reconstructing the specimen of interest given intensity-only measurements. If one thinks of x♮ as the specimen under study and uses {yi} to represent the intensity measurements, then phase retrieval is precisely about inverting the quadratic system (1).
Moving beyond physical sciences, the above problem also spans various machine learning applications. One example is mixed linear regression, where one wishes to estimate two unknown vectors β1 and β2 from unlabeled linear measurements [CYC14]. The acquired data {ai, bi}1≤i≤m take the form of either or , without knowing which of the two vectors generates the data. In a simple symmetric case with β1 = β2 = x♮ (so that ), the squared measurements become the sufficient statistics, and hence mixed linear regression can be converted to learning x♮ from {ai, yi}. Furthermore, the quadratic measurement model in (1) allows to represent a single neuron associated with a quadratic activation function, where {ai, yi} are the data and x♮ encodes the parameters to be learned. As described in [SJL17, LMZ17], learning neural nets with quadratic activations involves solving systems of quadratic equations.
1.1. Nonconvex optimization via gradient descent
A natural strategy for inverting the system of quadratic equations (1) is to solve the following nonconvex least squares estimation problem
| (2) |
Under Gaussian designs where , the solution to (2) is known to be exact — up to some global sign — with high probability, as soon as the number m of equations (samples) exceeds the order of the number n of unknowns [BCMN14]. However, the loss function in (2) is highly nonconvex, thus resulting in severe computational challenges. With this issue in mind, can we still hope to find the global minimizer of (2) via low-complexity algorithms which, ideally, run in time proportional to that taken to read the data?
Fortunately, in spite of nonconvexity, a variety of optimization-based methods are shown to be effective in the presence of proper statistical models. Arguably, one of the simplest algorithms for solving (2) is vanilla gradient descent (GD), which attempts recovery via the update rule
| (3) |
with ηt being the stepsize/learning rate. The above iterative procedure is also dubbed Wirtinger flow for phase retrieval, which can accommodate the complex-valued case as well [CLS15]. This simple algorithm is remarkably efficient under Gaussian designs: in conjunction with carefully-designed initialization and stepsize rules, GD provably converges to the truth x♮ at a linear rate1, provided that the ratio m/n of the number of equations to the number of unknowns exceeds some logarithmic factor [CLS15,Sol14,MWCC17].
One crucial element in prior convergence analysis is initialization. In order to guarantee linear convergence, prior works typically recommend spectral initialization or its variants [CLS15,CC17,WGE17,ZZLC17,MWCC17,LL17,MM17]. Specifically, the spectral method forms an initial estimate x0 using the (properly scaled) leading eigenvector of a certain data matrix. Two important features are worth emphasizing:
x0 convexity; falls within a local ℓ2-ball surrounding x♮ with a reasonably small radius, where f(·) enjoys strong convexity;
x0 is incoherent with all the design vectors {ai} — in the sense that is reasonably small for all 1 ≤ i ≤ m — and hence x0 falls within a region where f(·) enjoys desired smoothness conditions.
These two properties taken collectively allow gradient descent to converge rapidly from the very beginning.
1.2. Random initialization?
The enormous success of spectral initialization gives rise to a curious question: is carefully-designed initialization necessary for achieving fast convergence? Obviously, vanilla GD cannot start from arbitrary points, since it may get trapped in undesirable stationary points (e.g. saddle points). However, is there any simpler initialization approach that avoids such stationary points and works equally well as spectral initialization?
A strategy that practitioners often like to employ is to initialize GD randomly. The advantage is clear: compared with spectral methods, random initialization is model-agnostic and is usually more robust visa-vis model mismatch. Despite its wide use in practice, however, GD with random initialization is poorly understood in theory. One way to study this method is through a geometric lens [SQW16]: under Gaussian designs, the loss function f(·) (cf. (2)) does not have any spurious local minima as long as the sample size m is on the order of n log3 n. Moreover, all saddle points are strict [GHJY15], meaning that the associated Hessian matrices have at least one negative eigenvalue if they are not local minima. Armed with these two conditions, the theory of Lee et al. [LSJR16] implies that vanilla GD converges almost surely to the truth. However, the convergence rate remains unsettled. In fact, we are not aware of any theory that guarantees polynomial-time convergence of vanilla GD for phase retrieval in the absence of carefully-designed initialization.
Motivated by this, we aim to pursue a formal understanding about the convergence properties of GD with random initialization. Before embarking on theoretical analyses, we first assess its practical efficiency through numerical experiments. Generate the true object x♮ and the initial guess x0 randomly as
We vary the number n of unknowns (i.e. n = 100, 200, 500, 800, 1000), set m = 10n, and take a constant stepsize ηt ≡ 0.1. Here the measurement vectors are generated from Gaussian distributions, i.e. for 1 ≤ i ≤ m. The relative ℓ2 errors dist(xt, x♮)/∥x♮∥2 of the GD iterates in a random trial are plotted in Figure 1, where
| (4) |
represents the ℓ2 distance between xt and x♮ modulo the unrecoverable global sign.
Figure 1:
The relative ℓ2 error vs. iteration count for GD with random initialization, plotted semilogarithmically. The results are shown for n = 100, 200, 500, 800, 1000 with m = 10n and ηt ≡ 0.1.
In all experiments carried out in Figure 1, we observe two stages for GD: (1) Stage 1: the relative error of xt stays nearly flat; (2) Stage 2: the relative error of xt experiences geometric decay. Interestingly, Stage 1 lasts only for a few tens of iterations. These numerical findings taken together reveal appealing computational efficiency of GD in the presence of random initialization — it attains 5-digit accuracy within about 200 iterations!
To further illustrate this point, we take a closer inspection of the signal component ⟨xt, x♮⟩x♮ and the orthogonal component xt − ⟨xt, x♮⟩x♮, where we normalize for simplicity. Denote by the ℓ2 norm of the orthogonal component. We highlight two important and somewhat surprising observations that allude to why random initialization works.
The strength ratio of the signal to the orthogonal components grows exponentially. The ratio, , grows exponentially fast throughout the execution of the algorithm, as demonstrated in Figure 2(a). This metric in some sense captures the signal-to-noise ratio of the running iterates.
Exponential growth of the signal strength in Stage 1. While the ℓ2 estimation error of xt may not drop significantly during Stage 1, the size |⟨xt, x♮⟩| of the signal component increases exponentially fast and becomes the dominant component within several tens of iterations, as demonstrated in Figure 2(b). This helps explain why Stage 1 lasts only for a short duration.
Figure 2:
(a) The ratio , and (b) the size of the signal component and the ℓ2 error vs. iteration count, both plotted on semilogarithmic scales. The results are shown for n = 100, 200, 500, 800, 1000 with m = 10n, ηt ≡ 0.1, and .
The central question then amounts to whether one can develop a mathematical theory to interpret such intriguing numerical performance. In particular, how many iterations does Stage 1 encompass, and how fast can the algorithm converge in Stage 2?
1.3. Main findings
The objective of the current paper is to demystify the computational efficiency of GD with random initialization, thus bridging the gap between theory and practice. Assuming a tractable random design model in which ai’s follow Gaussian distributions, our main findings are summarized in the following theorem. Here and throughout, the notation f(n) ≲ g(n) or f(n) = O(g(n)) (resp. f(n) ≳ g(n), f(n) ≍ g(n)) means that there exist constants c1, c2 > 0 such that f(n) ≤ c1g(n) (resp. f(n) ≥ c2g(n), c1g(n) ≤ f(n) ≤ c2g(n)).
Theorem 1
Fix with ∥x♮∥2 = 1. Suppose that for 1 ≤ i ≤ m, , and for some sufficiently small constant c > 0. Then with probability approaching one, there exist some sufficiently small constant 0 < γ < 1 and Tγ ≲ log n such that the GD iterates (3) obey
for some absolute constant 0 < ρ < 1, provided that the sample size m ≳ n poly log(m).
Remark 1
The readers are referred to Theorem 2 for a more general statement.
Here, the stepsize is taken to be a fixed constant throughout all iterations, and we reuse the same data across all iterations (i.e. no sample splitting is needed to establish this theorem). The GD trajectory is divided into 2 stages: (1) Stage 1 consists of the first Tγ iterations, corresponding to the first tens of iterations discussed in Section 1.2; (2) Stage 2 consists of all remaining iterations, where the estimation error contracts linearly. Several important implications/remarks follow immediately.
- Stage 1 takes O(log n) iterations. When seeded with a random initial guess, GD is capable of entering a local region surrounding x♮ within Tγ ≲ log n iterations, namely,
for some sufficiently small constant γ > 0. Even though Stage 1 may not enjoy linear convergence in terms of the estimation error, it is of fairly short duration. Stage 2 takes O(log (1/ϵ)) iterations. After entering the local region, GD converges linearly to the ground truth x♮ with a contraction rate 1−ρ. This tells us that GD reaches ϵ-accuracy (in a relative sense) within O(log (1/ϵ)) iterations.
- Near linear-time computational complexity. Taken collectively, these imply that the iteration complexity of GD with random initialization is
Given that the cost of each iteration mainly lies in calculating the gradient ∇f(xt), the whole algorithm takes nearly linear time, namely, it enjoys a computational complexity proportional to the time taken to read the data (modulo some logarithmic factor). Near-minimal sample complexity. The preceding computational guarantees occur as soon as the sample size exceeds m ≳ n poly log(m). Given that one needs at least n samples to recover n unknowns, the sample complexity of randomly initialized GD is optimal up to some logarithmic factor.
Saddle points? The GD iterates never hit the saddle points (see Figure 3 for an illustration). In fact, after a constant number of iterations at the very beginning, GD will follow a path that increasingly distances itself from the set of saddle points as the algorithm progresses. There is no need to adopt sophisticated saddle-point escaping schemes developed in generic optimization theory (e.g. cubic regularization [NP06], perturbed GD [JGN+17]).
Weak dependency w.r.t. the design vectors. As we will elaborate in Section 4, the statistical dependency between the GD iterates {xt} and certain components of the design vectors {ai} stays at an exceedingly weak level. Consequently, the GD iterates {xt} proceed as if fresh samples were employed in each iteration. This statistical observation plays a crucial role in characterizing the dynamics of the algorithm without the need of sample splitting.
Figure 3:
The trajectory of (αt, βt), where αt = |⟨xt, x♮⟩| and βt = ∥xt − ⟨xt, x♮⟩x♮∥2 represent respectively the size of the signal component and that of the orthogonal component of the GD iterates (assume ∥x♮∥2 = 1). (a) The results are shown for n = 1000 with m = 10n, and ηt = 0.01, 0.05, 0.1. (b) The results are shown for n = 1000 with m approaching infinity, and ηt = 0.01, 0.05, 0.1. The blue filled circles represent the population-level saddle points, and the orange arrows indicate the directions of increasing t.
It is worth emphasizing that the entire trajectory of GD is automatically confined within a certain region enjoying favorable geometry. For example, the GD iterates are always incoherent with the design vectors, stay sufficiently away from any saddle point, and exhibit desired smoothness conditions, which we will formalize in Section 4. Such delicate geometric properties underlying the GD trajectory are not explained by prior papers. In light of this, convergence analysis based on global geometry [SQW16] — which provides valuable insights into algorithm designs with arbitrary initialization — results in suboptimal (or even pessimistic) computational guarantees when analyzing a specific algorithm like GD. In contrast, the current paper establishes near-optimal performance guarantees by paying particular attention to finer dynamics of the algorithm. As will be seen later, this is accomplished by heavily exploiting the statistical properties in each iterative update.
2. Why random initialization works?
Before diving into the proof of the main theorem, we pause to develop intuitions regarding why gradient descent with random initialization is expected to work. We will build our understanding step by step: (i) we first investigate the dynamics of the population gradient sequence (the case where we have infinite samples); (ii) we then turn to the finite-sample case and present a heuristic argument assuming independence between the iterates and the design vectors; (iii) finally, we argue that the true trajectory is remarkably close to the one heuristically analyzed in the previous step, which arises from a key property concerning the “near-independence” between {xt} and the design vectors {ai}.
Without loss of generality, we assume x♮ = e1 throughout this section, where e1 denotes the first standard basis vector. For notational simplicity, we denote by
| (5) |
the first entry and the 2nd through the nth entries of xt, respectively. Since x♮ = e1, it is easily seen that
| (6) |
represent respectively the components of xt along and orthogonal to the signal direction. In what follows, we focus our attention on the following two quantities that reflect the sizes of the preceding two components2
| (7) |
Without loss of generality, assume that α0 > 0.
2.1. Population dynamics
To start with, we consider the unrealistic case where the iterates {xt} are constructed using the population gradient (or equivalently, the gradient when the sample size m approaches infinity), i.e.
Here, ∇F(x) represents the population gradient given by
which can be computed by assuming that x and the ai’s are independent. Simple algebraic manipulation reveals the dynamics for both the signal and the orthogonal components:
| (8a) |
| (8b) |
Assuming that η is sufficiently small and recognizing that , we arrive at the following population-level state evolution for both αt and βt (cf. (7)):
| (9a) |
| (9b) |
This recursive system has three fixed points:
which correspond to the global minimizer, the local maximizer, and the saddle points, respectively, of the population objective function.
We make note of the following key observations in the presence of a randomly initialized x0, which will be formalized later in Lemma 1:
the ratio αt/βt of the size of the signal component to that of the orthogonal component increases exponentially fast;
the size αt of the signal component keeps growing until it plateaus around 1;
the size βt of the orthogonal component eventually drops towards zero.
In other words, when randomly initialized, (αt, βt) converges to (1, 0) rapidly, thus indicating rapid convergence of xt to the truth x♮, without getting stuck at any undesirable saddle points. We also illustrate these phenomena numerically. Set n = 1000, ηt ≡ 0.1 and . Figure 4 displays the dynamics of αt/βt, αt, and βt, which are precisely as discussed above.
Figure 4:
Population-level state evolution, plotted semilogarithmically: (a) the ratio αt/βt vs. iteration count, and (b) αt and βt vs. iteration count. The results are shown for n = 1000, ηt ≡ 0.1, and (assuming α0 > 0 though).
2.2. Finite-sample analysis: a heuristic treatment
We now move on to the finite-sample regime, and examine how many samples are needed in order for the population dynamics to be reasonably accurate. Notably, the arguments in this subsection are heuristic in nature, but they are useful in developing insights into the true dynamics of the GD iterates.
Rewrite the gradient update rule (3) as
| (10) |
where . Assuming (unreasonably) that the iterate xt is independent of {ai}, the central limit theorem (CLT) allows us to control the size of the fluctuation term r(xt). Take the signal component as an example: simple calculations give
where
| (11) |
with ai,1 the first entry of ai. Owing to the preceding independence assumption, r1 is the sum of m i.i.d. zero-mean random variables. Assuming that xt never blows up so that ∥xt∥2 = O(1), one can apply the CLT to demonstrate that
| (12) |
with high probability, which is often negligible compared to the other terms. For instance, for the random initial guess one has with probability approaching one, telling us that
as long as m ≳ n poly log(m). This combined with the fact that reveals . Similar observations hold true for the orthogonal component .
In summary, by assuming independence between xt and {ai}, we arrive at an approximate state evolution for the finite-sample regime:
| (13a) |
| (13b) |
with the proviso that m ≳ n poly log(m).
2.3. Key analysis ingredients: near-independence and leave-one-out tricks
The preceding heuristic argument justifies the approximate validity of the population dynamics, under an independence assumption that never holds unless we use fresh samples in each iteration. On closer inspection, what we essentially need is the fluctuation term r(xt) (cf. (10)) being well-controlled. For instance, when focusing on the signal component, one need for all t ≥ 0. In particular, in the beginning iterations, is as small as . Without the independence assumption, the CLT types of results fail to hold due to the complicated dependency between xt and {ai}. In fact, one can easily find many points that result in much larger remainder terms (as large as O(1)) and that violate the approximate state evolution (13). See Figure 5 for a caricature of the region where the fluctuation term r(xt) is well-controlled. As can be seen, it only occupies a tiny fraction of the neighborhood of x♮.
Figure 5:
Illustration of the region satisfying the “near-independence” property. Here, the green arrows represent the directions of {ai}1≤i≤20, and the blue region consists of all points such that the first entry r1 (x) of the fluctuation r(x) = ∇f(x) − ∇F(x) is bounded above in magnitude by .
Fortunately, despite the complicated dependency across iterations, one can provably guarantee that xt always stays within the preceding desirable region in which r(xt) is well-controlled. The key idea is to exploit a certain “near-independence” property between {xt} and {ai}. Towards this, we make use of a leave-one-out trick proposed in [MWCC17] for analyzing nonconvex iterative methods. In particular, we construct auxiliary sequences that are
independent of certain components of the design vectors {ai}; and
extremely close to the original gradient sequence {xt}t≥0.
As it turns out, we need to construct several auxiliary sequences {xt,(l)}t≥0, {xt,sgn}t≥0 and {xt,sgn,(l)}t≥0, where {xt,(l)}t≥0 is independent of the lth sampling vector al, {xt,sgn}t≥0 is independent of the sign information of the first entries of all ai’s, and {xt;sgn;(l)} is independent of both. In addition, these auxiliary sequences are constructed by slightly perturbing the original data (see Figure 6 for an illustration), and hence one can expect all of them to stay close to the original sequence throughout the execution of the algorithm. Taking these two properties together, one can propagate the above statistical independence underlying each auxiliary sequence to the true iterates {xt}, which in turn allows us to obtain near-optimal control of the fluctuation term r(xt). The details are postponed to Section 4.
Figure 6:
Illustration of the leave-one-out and random-sign sequences. (a) {xt} is constructed using all data {ai, yi}; (b) {xt,(l)} is constructed by discarding the lth sample {al, yl}; (c) {xt,sgn} is constructed by using auxiliary design vectors , where is obtained by randomly flipping the sign of the first entry of ai; (d) {xt,sgn,(l)} is constructed by discarding the lth sample .
3. Related work
Solving systems of quadratic equations, or phase retrieval, has been studied extensively in the recent literature; see [SEC+15] for an overview. One popular method is convex relaxation (e.g. PhaseLift [CSV13]), which is guaranteed to work as long as m/n exceeds some large enough constant [CL14,DH14,CCG15,CZ15,KRT17]. However, the resulting semidefinite program is computationally prohibitive for solving large-scale problems. To address this issue, [CLS15] proposed the Wirtinger flow algorithm with spectral initialization, which provides the first convergence guarantee for nonconvex methods without sample splitting. Both the sample and computation complexities were further improved by [CC17] with an adaptive truncation strategy. Other nonconvex phase retrieval methods include [NJS13,CLM16,Sol17,WGE17,ZZLC17,WGSC17,CL16,DR17,GX16,CFL15,Wei15,BEB17,TV17,CLW17,ZWGC17,QZEW17,ZCL16,YYF+17,CWZG17,Zha17,MXM18,CLC18]. Almost all of these nonconvex methods require carefully-designed initialization to guarantee a sufficiently accurate initial point. One exception is the approximate message passing algorithm proposed in [MXM18], which works as long as the correlation between the truth and the initial signal is bounded away from zero. This, however, does not accommodate the case when the initial signal strength is vanishingly small (like random initialization). Other works [Zha17,LGL15] explored the global convergence of alternating minimization/projection with random initialization which, however, require fresh samples at least in each of the first O(log n) iterations in order to enter the local basin. In addition, [LMZ17] explored low-rank recovery from quadratic measurements with near-zero initialization. Using a truncated least-squares objective, [LMZ17] established approximate (but non-exact) recovery of over-parametrized GD. Notably, if we do not over-parametrize the phase retrieval problem, then GD with near-zero initialization is (nearly) equivalent to running the power method for spectral initialization3, which can be understood using prior theory.
Another related line of research is the design of generic saddle-point escaping algorithms, where the goal is to locate a second-order stationary point (i.e. the point with a vanishing gradient and a positive-semidefinite Hessian). As mentioned earlier, it has been shown by [SQW16] that as soon as m ≫ log3 n, all local minima are global and all the saddle points are strict. With these two geometric properties in mind, saddle-point escaping algorithms are guaranteed to converge globally for phase retrieval. Existing saddle-point escaping algorithms include but are not limited to Hessian-based methods [NP06,SQW16] (see also [AAZB+16,AZ17,JGN+17] for some reviews), noisy stochastic gradient descent [GHJY15], perturbed gradient descent [JGN+17], and normalized gradient descent [MSK17]. On the one hand, the results developed in these works are fairly general: they establish polynomial-time convergence guarantees under a few generic geometric conditions. On the other hand, the iteration complexity derived therein may be pessimistic when specialized to a particular problem.
Take phase retrieval and the perturbed gradient descent algorithm [JGN+17] as an example. It has been shown in [JGN+17, Theorem 5] that for an objective function that is L-gradient Lipschitz, ρ-Hessian Lipschitz, (θ, γ, ζ)-strict saddle, and also locally α-strongly convex and β-smooth (see definitions in [JGN+17]), it takes4
iterations (ignoring logarithmic factors) for perturbed gradient descent to converge to ϵ-accuracy. In fact, even with Nesterov’s accelerated scheme [JNJ17], the iteration complexity for entering the local region is at least
Both of them are much larger than the O(log n + log(1/ϵ)) complexity established herein. This is primarily due to the following facts: (i) the Lipschitz constants of both the gradients and the Hessians are quite large, i.e. L ≍ n and ρ ≍ n (ignoring log factors), which are, however, treated as dimension-independent constants in the aforementioned papers; (ii) the local condition number is also large, i.e. β/α ≍ n. In comparison, as suggested by our theory, the GD iterates with random initialization are always confined within a restricted region enjoying much more benign geometry than the worst-case / global characterization.
Furthermore, the above saddle-escaping first-order methods are often more complicated than vanilla GD. Despite its algorithmic simplicity and wide use in practice, the convergence rate of GD with random initialization remains largely unknown. In fact, Du et al. [DJL+17] demonstrated that there exist non-pathological functions such that GD can take exponential time to escape the saddle points when initialized randomly. In contrast, as we have demonstrated, saddle points are not an issue for phase retrieval; the GD iterates with random initialization never get trapped in the saddle points.
Finally, the leave-one-out arguments have been invoked to analyze other high-dimensional statistical inference problems including robust M-estimators [EKBB+13,EK15], and maximum likelihood theory for logistic regression [SCC18], etc. In addition, [ZB17,CFMW17,AFWZ17] made use of the leave-one-out trick to derive entrywise perturbation bounds for eigenvectors resulting from certain spectral methods. The techniques have also been applied by [MWCC17,LMCC18] to establish local linear convergence of vanilla GD for nonconvex statistical estimation problems in the presence of proper spectral initialization.
4. Analysis
In this section, we first provide a more general version of Theorem 1 as follows. It spells out exactly the conditions on x0 in order for vanilla GD with random initialization to succeed.
Theorem 2
Fix . Suppose and m ≥ Cn log13m for some sufficiently large constant C > 0. Assume that the initialization x0 is independent of {ai} and obeys
| (14) |
and that the stepsize satisfies for some sufficiently small constant c > 0. Then there exist a sufficiently small absolute constant 0 < γ < 1 and Tγ ≲ log n such that with probability at least 1 − O(m2e−1.5n) − O(m−9),
- the GD iterates (3) converge linearly to x♮ after t ≥ Tγ, namely,
- the strength ratio of the signal component to the orthogonal component obeys
for some constant c1 > 0.(15)
Several remarks regarding Theorem 2 are in order.
Our current sample complexity reads m ≳ n log13 m, which is optimal up to logarithmic factors. It is possible to further reduce the logarithmic factors using more refined probabilistic tools, which we leave for future work.
We can also prove similar performance guarantees for noisy phase retrieval. For brevity, we do not provide the exact theorem and the detailed proofs. The readers will find them in the last author’s Ph.D. thesis.
The random initialization obeys the condition (14) with probability exceeding , which in turn establishes Theorem 1.
Theorem 2 requires an initialization x0 which is independent of the data and the knowledge of ∥x♮∥, which is not practical. One possible method is to estimate it from the data, which results in an initial value that depends on the data. The following theorem demonstrate both independent initial value and known ∥x♮∥ are not necessary, resulting a practical algorithm.
Theorem 3
Let
where u is uniformly distributed over the unit sphere. With probability at least all the claims in Theorem 2 continue to hold.
Proof. The proof is very similar to that of Theorem 2, with only a few changes. See Appendix N for detailed explanations. □
The remainder of this section is then devoted to proving Theorem 2. Without loss of generality5, we will assume throughout that
| (16) |
Given this, one can decompose
| (17) |
where and as introduced in Section 2. For notational simplicity, we define
| (18) |
Intuitively, αt represents the size of the signal component, whereas βt measures the size of the component orthogonal to the signal direction. In view of (16), we have α0 > 0.
4.1. Outline of the proof
To begin with, it is easily seen that if αt and βt (cf. (18)) obey |αt − 1| ≤ γ/2 and βt ≤ γ/2, then
Therefore, our first step — which is concerned with proving — comes down to the following two steps.
- Show that if αt and βt satisfy the approximate state evolution (see (13)), then there exists some Tγ = O (log n) such that
which would immediately imply that(19)
Along the way, we will also show that the ratio αt/βt grows exponentially fast. Justify that αt and βt satisfy the approximate state evolution with high probability, using (some variants of) leave-one-out arguments.
After t ≥ Tγ, we can invoke prior theory [MWCC17] concerning local convergence to show that with high probability,
for some constant 0 < ρ < 1 independent of n and m.
4.2. Dynamics of approximate state evolution
This subsection formalizes our intuition in Section 2: as long as the approximate state evolution holds, then one can find Tγ ≲ log n obeying condition (19). In particular, the approximate state evolution is given by
| (20a) |
| (20b) |
where {ζt} and {ρt} represent the perturbation terms. Our result is this:
Lemma 1
Let γ > 0 be some sufficiently small constant, and consider the approximate state evolution (20). Suppose the initial point obeys
| (21) |
and the perturbation terms satisfy
for some sufficiently small constant c3 > 0.
(a) Let
| (22) |
Then for any sufficiently large n and m and any sufficiently small constant η > 0, one has
| (23) |
and there exist some constants c5, c10 > 0 independent of n and m such that
| (24) |
(b) If we define
| (25) |
| (26) |
for some arbitrarily small constants c4, c6 > 0, then
T0 ≤ T1 ≤ Tγ ≲ log n; T1 − T0 ≲ log log m; Tγ − T1 ≲ 1;
For T0 < t ≤ Tγ, one has αt ≥ c6/log5 m.
Proof. See Appendix B. □
Remark 2
Recall that γ is sufficiently small and (α, β) = (1, 0) represents the global minimizer. Since |α0−1| ≈ 1, one has Tγ > 0, which denotes the first time when the iterates enter the local region surrounding the global minimizer. In addition, the fact that gives T0 > 0 and T1 > 0, both of which indicate the first time when the signal strength is sufficiently large.
Lemma 1 makes precise that under the approximate state evolution, the first stage enjoys a fairly short duration Tγ ≲ log n. Moreover, the size of the signal component grows faster than that of the orthogonal component for any iteration t < Tγ, thus confirming the exponential growth of αt/βt.
In addition, Lemma 1 identifies two midpoints T0 and T1 when the sizes of the signal component αt become sufficiently large. These are helpful in our subsequent analysis. In what follows, we will divide Stage 1 (which consists of all iterations up to Tγ) into two phases:
Phase I: consider the duration 0 ≤ t ≤ T0;
Phase II: consider all iterations with T0 < t ≤ Tγ.
We will justify the approximate state evolution (20) for these two phases separately.
4.3. Motivation of the leave-one-out approach
As we have alluded in Section 2.3, the main difficulty in establishing the approximate state evolution (20) lies in controlling the perturbation terms to the desired orders (i.e. |ζt|, |ρt| ≪ 1/log n in Lemma 1). To achieve this, we advocate the use of (some variants of) leave-one-out sequences to help establish certain “near-independence” between xt and certain components of {ai}.
We begin by taking a closer look at the perturbation terms. Regarding the signal component, it is easily seen from (11) that
where the perturbation term r1(xt) obeys
| (27) |
Here and throughout the paper, for any vector , denotes the 2nd through the nth entries of v. Due to the dependency between xt and {ai}, it is challenging to obtain sharp control of some of these terms.
In what follows, we use the term I4 to explain and motivate our leave-one-out approach. As discussed in Section 2.3, I4 needs to be controlled to the level . This precludes us from seeking a uniform bound on the function over all x (or even all x within the set incoherent with {ai}), since the uniform bound can be times larger than the desired order.
Algorithm 1.
The lth leave-one-out sequence
| Input: {ai}1≤i≤m,i≠l, {yi}1≤i≤m,i≠l, and x0. | ||
Gradient updates: for
t = 0, 1, 2, …, T − 1 do
|
In order to control I4 to the desirable order, one strategy is to approximate it by a sum of independent variables and then invoke the CLT. Specifically, we first rewrite I4 as
with ξi := sgn(ai,1). Here sgn(·) denotes the usual sign function. To exploit the statistical independence between ξi and {|ai,1|,ai,⊥}, we would like to identify some vector independent of ξi that well approximates xt. If this can be done, then one may treat I4 as a weighted independent sum of {ξi}. Viewed in this light, our plan is the following:
- Construct a sequence {xt,sgn} independent of {ξi} obeying xt,sgn ≈ xt, so that
One can then apply standard concentration results (e.g. the Bernstein inequality) to control I4, as long as none of the weight wi is exceedingly large. - Demonstrate that the weight wi is well-controlled, or equivalently, is not much larger than its typical size. This can be accomplished by identifying another sequence {xt,(i)} independent of ai such that xt,(i) ≈ xt ≈ xt,sgn, followed by the argument:
Here, the inequality follows from standard Gaussian tail bounds and the independence between ai and xt,(i). This explains why we would like to construct {xt,(i)} for each 1 ≤ i ≤ m.(28)
As we will detail in the next subsection, such auxiliary sequences are constructed by leaving out a small amount of relevant information from the collected data before running the GD algorithm, which is a variant of the “leave-one-out” approach rooted in probability theory and random matrix theory.
4.4. Leave-one-out and random-sign sequences
We now describe how to design auxiliary sequences to help establish certain independence properties between the gradient iterates {xt} and the design vectors {ai}. In the sequel, we formally define the three sets of auxiliary sequences {xt,(l)},{xt,sgn},{xt,sgn,(l)} as introduced in Section 2.3 and Section 4.3.
- Leave-one-out sequences {xt,(l)}t≥0. For each 1 ≤ l ≤ m, we introduce a sequence {xt,(l)}, which drops the lth sample and runs GD w.r.t. the auxiliary objective function
See Algorithm 1 for details and also Figure 6(a) for an illustration. One of the most important features of {xt,(l)} is that all of its iterates are statistically independent of (al, yl), and hence are incoherent with al with high probability, in the sense that . Such incoherence properties further allow us to control both and (see (28)), which is crucial for controlling the size of the residual terms (e.g. r1(xt) as defined in (11)). Notably, the sequence {xt,(l)} has also been applied by [MWCC17] to justify the success of GD with spectral initialization for several nonconvex statistical estimation problems.(32)
Algorithm 2.
The random-sign sequence
| Input: {|ai,1|}1≤i≤m, {ai,⊥}1≤i≤m, , {yi}1≤i≤m, x0. | ||
Gradient updates: for
t = 0, 1, 2, …, T − 1 do
|
Algorithm 3.
The lth leave-one-out and random-sign sequence
| Input: {|ai,1|}1≤i≤m,i≠l, {ai,⊥}1≤i≤m,i≠l, , {yi}1≤i≤m,i≠l, x0. | ||
Gradient updates: for
t = 0, 1, 2, …, T − 1 do
|
- Random-sign sequence {xt,sgn}t≥0. Introduce a collection of auxiliary design vectors defined as
where is a set of Rademacher random variables independent of {ai}, i.e.(33)
In words, is generated by randomly flipping the sign of the first entry of ai. To simplify the notations hereafter, we also denote(34)
As a result, ai and differ only by a single bit of information. With these auxiliary design vectors in place, we generate a sequence {xt,sgn} by running GD w.r.t. the auxiliary loss function(35)
One simple yet important feature associated with these new design vectors is that it produces the same measurements as {ai}:(36)
See Figure 6(b) for an illustration and Algorithm 2 for the detailed procedure. This sequence is introduced in order to “randomize” certain Gaussian polynomials (e.g. I4 in (27)), which in turn enables optimal control of these quantities. This is particularly crucial at the initial stage of the algorithm.(37) Leave-one-out and random-sign sequences {xt,sgn,(l)}t≥0. Furthermore, we also need to introduce another collection of sequences {xt,sgn,(l)} by simultaneously employing the new design vectors and discarding a single sample . This enables us to propagate the kinds of independence properties across the above two sets of sequences, which is useful in demonstrating that xt is jointly “nearly-independent” of both al and {sgn(ai,1)}. See Algorithm 3 and Figure 6(c).
As a remark, all of these leave-one-out and random-sign procedures are assumed to start from the same initial point as the original sequence, namely,
| (38) |
4.5. Justification of approximate state evolution for Phase I of Stage 1
Recall that Phase I consists of the iterations 0 ≤ t ≤ T0, where
| (39) |
Our goal here is to show that the approximate state evolution (20) for both the size αt of the signal component and the size βt of the orthogonal component holds true throughout Phase I. Our proof will be inductive in nature. Specifically, we will first identify a set of induction hypotheses that are helpful in proving the validity of the approximate state evolution (20), and then proceed by establishing these hypotheses via induction.
4.5.1. Induction hypotheses
For the sake of clarity, we first list all the induction hypotheses.
| (40a) |
| (40b) |
| (40c) |
| (40d) |
| (40e) |
| (40f) |
where C1,· · ·, C5 and c5 are some absolute positive constants.
Now we are ready to prove an immediate consequence of the induction hypotheses (40): if (40) hold for the tth iteration, then αt+1 and βt+1 follow the approximate state evolution (see (20)). This is justified in the following lemma.
Lemma 2
Suppose m ≥ Cn log11 m for some sufficiently large constant C > 0. For any 0 ≤ t ≤ T0 (cf. (39)), if the tth iterates satisfy the induction hypotheses (40), then with probability at least 1 − O(me−1.5n) − O(m−10),
| (41a) |
| (41b) |
hold for some |ζt| ≪ 1/log m and |ρt| ≪ 1/log m.
Proof. See Appendix C. □
It remains to inductively show that the hypotheses hold for all 0 ≤ t ≤ T0. Before proceeding to this induction step, it is helpful to first develop more understanding about the preceding hypotheses.
In words, (40a), (40b), (40c) specify that the leave-one-out sequences {xt,(l)} and {xt,sgn} are exceedingly close to the original sequence {xt}. Similarly, the difference between xt − xt,sgn and xt,(l) − xt,sgn,(l) is extremely small, as asserted in (40d). The hypothesis (40e) says that the norm of the iterates {xt} is always bounded from above and from below in Phase I. The last one (40f) indicates that the size αt of the signal component is never too small compared with ∥xt∥2.
Another property that is worth mentioning is the growth rate (with respect to t) of the quantities appeared in the induction hypotheses (40). For instance, , ∥xt−xt,sgn∥2 and ∥xt−xt,sgn−xt,(l)+xt,sgn,(l)∥2 grow more or less at the same rate as αt (modulo some factor). In contrast, ∥xt −xt,(l)∥2 shares the same growth rate with βt (modulo the factor). See Figure 7 for an illustration. The difference in the growth rates turns out to be crucial in establishing the advertised result.
Last but not least, we emphasize the sizes of the quantities of interest in (40) for t = 1 under the Gaussian initialization. Ignoring all of the log m terms and recognizing that and β1 ≍ 1, one sees that , , and ∥x1−x1,sgn−x1,(l)+x1,sgn,(l)∥2 ≲ 1/m. See Figure 7 for an illustration of the trends of the above four quantities.
Figure 7:
Illustration of the differences among leave-one-out and original sequences vs. iteration count, plotted semilogarithmically. The results are shown for n = 1000 with m = 10n, ηt ≡ 0.1, and . (a) The four differences increases in Stage 1. From the induction hypotheses (40), our upper bounds on , ∥xt − xt,sgn∥2 and ∥xt − xt,sgn − xt,(l) + xt,sgn,(l)∥2 scale linearly with αt, whereas the upper bound on ∥xt − xt,(l)∥2 is proportional to βt. In addition, , , and ∥x1 − x1,sgn − x1,(l) + x1,sgn,(l)∥2 ≲ 1/m. (b) The four differences converge to zero geometrically fast in Stage 2, as all the (variants of) leave-one-out sequences and the original sequence converge to the truth x♮.
Several consequences of (40) regarding the incoherence between {xt}, {xt,sgn} and {ai}, are immediate, as summarized in the following lemma.
Lemma 3
Suppose that m ≥ Cn log6m for some sufficiently large constant C > 0 and the tth iterates satisfy the induction hypotheses (40) for t ≤ T0, then with probability at least 1 − O(me−1.5n) − O(m−10),
Proof. These incoherence conditions typically arise from the independence between {xt,(l)} and al. For instance, the first line follows since
See Appendix M for detailed proofs. □
4.5.2. Induction step
We then turn to showing that the induction hypotheses (40) hold throughout Phase I, i.e. for 0 ≤ t ≤ T0. The base case can be easily verified because of the identical initial points (38). Now we move on to the inductive step, i.e. we aim to show that if the hypotheses (40) are valid up to the tth iteration for some t ≤ T0, then they continue to hold for the (t + 1)th iteration.
The first lemma concerns the difference between the leave-one-out sequence xt+1,(l) and the true sequence xt+1 (see (40a)).
Lemma 4
Suppose m ≥ Cnlog5 m for some sufficiently large constant C > 0. If the induction hypotheses (40) hold true up to the tth iteration for some t ≤ T0, then with probability at least 1−O(me−1.5n)−O(m−10),
| (43) |
holds as long as η > 0 is a sufficiently small constant and C1 > 0 is sufficiently large.
Proof. See Appendix D. □
The next lemma characterizes a finer relation between xt+1 and xt+1,(l) when projected onto the signal direction (cf. (40b)).
Lemma 5
Suppose m ≥ Cnlog6 m for some sufficiently large constant C > 0. If the induction hypotheses (40) hold true up to the tth iteration for some t ≤ T0, then with probability at least 1−O(me−1.5n)−O(m−10),
| (44) |
holds as long as η > 0 is a sufficiently small constant and C2 ≫ C4.
Proof. See Appendix E. □
Regarding the difference between xt and xt,sgn (see (40c)), we have the following result.
Lemma 6
Suppose m ≥ Cnlog5 m for some sufficiently large constant C > 0. If the induction hypotheses (40) hold true up to the tth iteration for some t ≤ T0, then with probability at least 1−O(me−1.5n)−O(m−10),
| (45) |
holds as long as η > 0 is a sufficiently small constant and C3 is a sufficiently large positive constant.
Proof. See Appendix F. □
We are left with the double difference xt+1 − xt+1,sgn − xt+1,(l) + xt+1,sgn,(l) (cf. (40d)), for which one has the following lemma.
Lemma 7
Suppose m ≥ Cnlog8 m for some sufficiently large constant C > 0. If the induction hypotheses (40) hold true up to the tth iteration for some t ≤ T0, then with probability at least 1−O(me−1.5n)−O(m−10),
| (46) |
holds as long as η > 0 is a sufficiently small constant and C4 > 0 is sufficiently large.
Proof. See Appendix G. □
Assuming the induction hypotheses (40) hold up to the tth iteration for some t ≤ T0, we know from Lemma 2 that the approximate state evolution for both αt and βt (see (20)) holds up to t + 1. As a result, the last two hypotheses (40e) and (40f) for the (t + 1)th iteration can be easily verified.
4.6. Justification of approximate state evolution for Phase II of Stage 1
Recall from Lemma 1 that Phase II refers to the iterations T0 < t ≤ Tγ (see the definition of T0 in Lemma 1), for which one has
| (47) |
as long as the approximate state evolution (20) holds. Here c6 > 0 is the same constant as in Lemma 1. Similar to Phase I, we invoke an inductive argument to prove that the approximate state evolution (20) continues to hold for T0 < t ≤ Tγ.
4.6.1. Induction hypotheses
In Phase I, we rely on the leave-one-out sequences and the random-sign sequences {xt,(l)}, {xt,sgn} and {xt,sgn,(l)} to establish certain “near-independence” between {xt} and {al}, which in turn allows us to obtain sharp control of the residual terms r (xt) (cf. (10)) and r1 (xt) (cf. (11)). As it turns out, once the size αt of the signal component obeys αt ≳ 1/poly log(m), then {xt,(l)} alone is sufficient for our purpose to establish the “near-independence” property. More precisely, in Phase II we only need to impose the following induction hypotheses.
| (48a) |
| (48b) |
A direct consequence of (48) is the incoherence between xt and {al}, namely,
| (49a) |
| (49b) |
To see this, one can use the triangle inequality to show that
where (i) follows from the independence between al and xt,(l) and the Cauchy-Schwarz inequality, and the last line (ii) arises from (1 + 1/log m)t ≲ 1 for t ≤ Tγ ≲ log n and m ≫ n log15/2m. This combined with the fact that results in
| (50) |
The condition (49b) follows using nearly identical arguments, which are omitted here.
As in Phase I, we need to justify the approximate state evolution (20) for both αt and βt, given that the tth iterates satisfy the induction hypotheses (48). This is stated in the following lemma.
Lemma 8
Suppose m ≥ Cnlog13 m for some sufficiently large constant C > 0. If the tth iterates satisfy the induction hypotheses (48) for T0 < t < Tγ, then with probability at least 1 − O(me−1.5n) − O(m−10),
| (51a) |
| (51b) |
for some |ζt| ≪ 1/log m and |ρt| ≪ 1/log m
Proof. See Appendix H for the proof of (51a). The proof of (51b) follows exactly the same argument as in proving (41b), and is hence omitted. □
4.6.2. Induction step
We proceed to complete the induction argument. Towards this end, one has the following lemma in regard to the induction on max1≤l≤m ∥xt+1 − xt+1,(l)∥2 (see (48a)).
Lemma 9
Suppose m ≥ Cnlog5 m for some sufficiently large constant C > 0, and consider any T0 < t < Tγ. If the induction hypotheses (40) are valid throughout Phase I and (48) are valid from the T0th to the tth iterations, then with probability at least 1 − O(me−1.5n) − O(m−10),
holds as long as η > 0 is sufficiently small and C6 > 0 is sufficiently large.
Proof. See Appendix I. □
As in Phase I, since we assume the induction hypotheses (40) (resp. (48)) hold for all iterations up to the T0th iteration (resp. between the T0th and the tth iteration), we know from Lemma 8 that the approximate state evolution for both αt and βt (see (20)) holds up to t + 1. The last induction hypothesis (48b) for the (t + 1)th iteration can be easily verified from Lemma 1.
It remains to check the case when t = T0 + 1. It can be seen from the analysis in Phase I that
for some constant condition C6 ≫ 1, where the second line holds since , .
4.7. Analysis for Stage 2
Combining the analyses in Phase I and Phase II, we finish the proof of Theorem 2 for Stage 1, i.e. t ≤ Tγ. In addition to , we can also see from (49b) that
which in turn implies that
Armed with these properties, one can apply the arguments in [MWCC17, Section 6] to prove that for t ≥ Tγ + 1,
| (52) |
Notably, the theorem therein [MWCC17, Theorem 1] works under the stepsize ηt ≡ η ≍ c/log n when m ≫ n log n. Nevertheless, as remarked by the authors, when the sample complexity exceeds m ≫ n log3m, a constant stepsize is allowed.
We are left with proving (15) for Stage 2. Note that we have already shown that the ratio αt/βt increases exponentially fast in Stage 1. Therefore,
and, by the definition of T1 (see (26)) and Lemma 1, one has and hence
| (53) |
When it comes to t > Tγ, in view of (52), one has
where (i) arises from (53) and the fact that γ is a constant, (ii) follows since Tγ – T1 ≍ 1 according to Lemma 1, and the last line holds as long as c10 > 0 and η are sufficiently small. This concludes the proof regarding the lower bound on αt/βt.
5. Discussions
The current paper justifies the fast global convergence of gradient descent with random initialization for phase retrieval. Specifically, we demonstrate that GD with random initialization takes only O(log n + log(1/ϵ)) iterations to achieve a relative ϵ-accuracy in terms of the estimation error. It is likely that such fast global convergence properties also arise in other nonconvex statistical estimation problems. The technical tools developed herein may also prove useful for other settings. We conclude our paper with a few directions worthy of future investigation.
Sample complexity and phase transition. We have proved in Theorem 2 that GD with random initialization enjoys fast convergence, with the proviso that m ≫ n log13m. It is possible to improve the sample complexity via more sophisticated arguments. In addition, it would be interesting to examine the phase transition phenomenon of GD with random initialization.
Other nonconvex statistical estimation problems. We use the phase retrieval problem to showcase the efficiency of GD with random initialization. It is certainly interesting to investigate whether this fast global convergence carries over to other nonconvex statistical estimation problems including low-rank matrix and tensor recovery [KMO10,SL16,CW15,TBS+16,ZL16,ZWL15,MWCC17,CL17,CC18,CCF18,HZC18], blind deconvolution [LLSW18,MWCC17,HH17] and neural networks [SJL17,LMZ17,FCL18]. The leave-one-out sequences and the “near-independence” property introduced/identified in this paper might be useful in proving efficiency of randomly initialized GD for the aforementioned problems.
Noisy setting and other activation functions. Throughout this paper, our focus is on inverting noiseless quadratic systems. Extensions to the noisy case is definitely worth investigating. Moving beyond quadratic samples, one may also study other activation functions, including but not limited to Rectified Linear Units (ReLU), polynomial functions and sigmoid functions. Such investigations might shed light on the effectiveness of GD with random initialization for training neural networks.
Other iterative optimization methods. Apart from gradient descent, other iterative procedures have been applied to solve the phase retrieval problem. Partial examples include alternating minimization, Kaczmarz algorithm, and truncated gradient descent (Truncated Wirtinger flow). In conjunction with random initialization, whether the iterative algorithms mentioned above enjoy fast global convergence is an interesting open problem. For example, it has been shown that truncated WF together with truncated spectral initialization achieves optimal sample complexity (i.e. m ≍ n) and computational complexity simultaneously [CC17]. Does truncated Wirtinger flow still enjoy optimal sample complexity when initialized randomly?
Beyond Gaussian sampling vectors. In this work, we consider the Gaussian phase retrieval problem where the sampling vectors are i.i.d. Gaussian vectors. We expect our results to generalize to other sampling vectors. Experimentally, we can verify that random initialization also converges fast under a Rademacher sampling model; see Figure 8.
Applications of leave-one-out tricks. In this paper, we heavily deploy the leave-one-out trick to demonstrate “near-independence” between the iterates xt and the sampling vectors {ai}. The basic idea is to construct an auxiliary sequence that is (i) independent w.r.t. certain components of the design vectors, and (ii) extremely close to the original sequence. These two properties allow us to propagate the desired independence properties to xt. As mentioned in Section 3, the leave-one-out trick has served as a very powerful hammer for decoupling the dependency between random vectors in several high-dimensional estimation problems. We expect this powerful trick to be useful in broader settings.
Figure 8:
The relative ℓ2 error vs. iteration count for GD with random initialization, plotted semilogarithvectorsmically. The results are shown for n = 1000 with m = 10n and ηt ≡ 0.1. Here the entries of the sampling ai are drawn i.i.d. from a Rademacher distribution.
Supplementary Material
Acknowledgements
Y. Chen is supported in part by the AFOSR YIP award FA9550-19-1-0030, by the ARO grant W911NF-18-1-0303, and by the Princeton SEAS innovation award. Y. Chi is supported in part by AFOSR under the grant FA9550-15-1-0205, by ONR under the grant N00014-18-1-2142, by ARO under the grant W911NF-18-1-0303, and by NSF under the grants CAREER ECCS-1818571 and CCF-1806154. J. Fan is supported in part by NSF grants DMS-1662139 and DMS-1712591 and NIH grant 2R01-GM072611-13.
Footnotes
An iterative algorithm is said to enjoy linear convergence if the iterates {xt} converge geometrically fast to the minimizer x♮.
Here, we do not take the absolute value of . As we shall see later, the ‘s are of the same sign throughout the execution of the algorithm.
More specifically, the GD update when xt ≈ 0, which is equivalent to a power iteration (without normalization) w.r.t. the data matrix .
When applied to phase retrieval with m ≍ n poly log n, one has L ≍ n, ρ ≍ n, θ ≍ γ ≍ 1 (see [SQW16, Theorem 2.2]), α ≍ 1, and β ≳ n (ignoring logarithmic factors).
This is because of the rotational invariance of Gaussian distributions.
References
- [AAZB+16].Agarwal N, Allen-Zhu Z, Bullins B, Hazan E, and Ma T Finding approximate local minima for nonconvex optimization in linear time. arXiv preprint arXiv:1611.01146, 2016. [Google Scholar]
- [AFWZ17].Abbe E, Fan J, Wang K, and Zhong Y Entrywise eigenvector analysis of random matrices with low expected rank. arXiv preprint arXiv:1709.09565, 2017. [DOI] [PMC free article] [PubMed] [Google Scholar]
- [AZ17].Allen-Zhu Z Natasha 2: Faster non-convex optimization than sgd. arXiv preprint arXiv:1708.08694, 2017. [Google Scholar]
- [BCMN14].Bandeira AS, Cahill J, Mixon DG, and Nelson AA Saving phase: Injectivity and stability for phase retrieval. Applied and Computational Harmonic Analysis, 37(1):106–125, 2014. [Google Scholar]
- [BEB17].Bendory T, Eldar YC, and Boumal N Non-convex phase retrieval from STFT measurements. IEEE Transactions on Information Theory, 2017. [Google Scholar]
- [CC17].Chen Y and Candès EJ Solving random quadratic systems of equations is nearly as easy as solving linear systems. Comm. Pure Appl. Math, 70(5):822–883, 2017. [Google Scholar]
- [CC18].Chen Y and Candès E The projected power method: An efficient algorithm for joint alignment from pairwise differences. Communications on Pure and Applied Mathematics, 71(8):1648–1714, 2018. [Google Scholar]
- [CCF18].Chen Y, Cheng C, and Fan J Asymmetry helps: Eigenvalue and eigenvector analyses of asymmetrically perturbed low-rank matrices. arXiv preprint arXiv:1811.12804, 2018. [DOI] [PMC free article] [PubMed] [Google Scholar]
- [CCG15].Chen Y, Chi Y, and Goldsmith AJ Exact and stable covariance estimation from quadratic sampling via convex programming. IEEE Transactions on Information Theory, 61(7):4034–4059, 2015. [Google Scholar]
- [CESV13].Candès EJ, Eldar YC, Strohmer T, and Voroninski V Phase retrieval via matrix completion. SIAM Journal on Imaging Sciences, 6(1):199–225, 2013. [Google Scholar]
- [CFL15].Chen P, Fannjiang A, and Liu G-R Phase retrieval with one or two diffraction patterns by alternating projections with the null initialization. Journal of Fourier Analysis and Applications, pages 1–40, 2015. [Google Scholar]
- [CFMW17].Chen Y, Fan J, Ma C, and Wang K Spectral method and regularized MLE are both optimal for top-K ranking. arXiv preprint arXiv:1707.09971, 2017. [DOI] [PMC free article] [PubMed] [Google Scholar]
- [CL14].Candès EJ and Li X Solving quadratic equations via PhaseLift when there are about as many equations as unknowns. Foundations of Computational Mathematics, 14(5):1017–1026, 2014. [Google Scholar]
- [CL16].Chi Y and Lu YM Kaczmarz method for solving quadratic equations. IEEE Signal Processing Letters, 23(9):1183–1187, 2016. [Google Scholar]
- [CL17].Chen J and Li X Memory-efficient kernel PCA via partial matrix sampling and nonconvex optimization: a model-free analysis of local minima. arXiv preprint arXiv:1711.01742, 2017. [Google Scholar]
- [CLC18].Chi Y, Lu YM, and Chen Y Nonconvex optimization meets low-rank matrix factorization: An overview. arXiv preprint arXiv:1809.09573, 2018. [Google Scholar]
- [CLM16].Cai TT, Li X, and Ma Z Optimal rates of convergence for noisy sparse phase retrieval via thresholded Wirtinger flow. The Annals of Statistics, 44(5):2221–2251, 2016. [Google Scholar]
- [CLS15].Candès EJ, Li X, and Soltanolkotabi M Phase retrieval via Wirtinger flow: Theory and algorithms. IEEE Transactions on Information Theory, 61(4):1985–2007, April 2015. [Google Scholar]
- [CLW17].Cai J-F, Liu H, and Wang Y Fast rank one alternating minimization algorithm for phase retrieval. arXiv preprint arXiv:1708.08751, 2017. [Google Scholar]
- [CSV13].Candès EJ, Strohmer T, and Voroninski V Phaselift: Exact and stable signal recovery from magnitude measurements via convex programming. Communications on Pure and Applied Mathematics, 66(8):1017–1026, 2013. [Google Scholar]
- [CW15].Chen Y and Wainwright MJ Fast low-rank estimation by projected gradient descent: General statistical and algorithmic guarantees. arXiv preprint arXiv:1509.03025, 2015. [Google Scholar]
- [CWZG17].Chen J, Wang L, Zhang X, and Gu Q Robust wirtinger flow for phase retrieval with arbitrary corruption. arXiv preprint arXiv:1704.06256, 2017. [Google Scholar]
- [CYC14].Chen Y, Yi X, and Caramanis C A convex formulation for mixed regression with two components: Minimax optimal rates. In Conference on Learning Theory, pages 560–604, 2014. [Google Scholar]
- [CZ15].Cai T and Zhang A ROP: Matrix recovery via rank-one projections. The Annals of Statistics, 43(1):102–138, 2015. [Google Scholar]
- [DH14].Demanet L and Hand P Stable optimizationless recovery from phaseless linear measurements. Journal of Fourier Analysis and Applications, 20(1):199–221, 2014. [Google Scholar]
- [DJL+17].Du SS, Jin C, Lee JD, Jordan MI, Singh A, and Poczos B Gradient descent can take exponential time to escape saddle points. In Advances in Neural Information Processing Systems, pages 1067–1077, 2017. [Google Scholar]
- [DR17].Duchi JC and Ruan F Solving (most) of a set of quadratic equalities: Composite optimization for robust phase retrieval. arXiv preprint arXiv:1705.02356, 2017. [Google Scholar]
- [EK15].El Karoui N On the impact of predictor geometry on the performance on high-dimensional ridge-regularized generalized robust regression estimators. Probability Theory and Related Fields, pages 1–81, 2015. [Google Scholar]
- [EKBB+13].Karoui N. El, Bean D, Bickel PJ, Lim C, and Yu B On robust regression with high-dimensional predictors. Proceedings of the National Academy of Sciences, 110(36):14557–14562, 2013. [DOI] [PMC free article] [PubMed] [Google Scholar]
- [FCL18].Fu H, Chi Y, and Liang Y Local geometry of one-hidden-layer neural networks for logistic regression. arXiv preprint arXiv:1802.06463, 2018. [Google Scholar]
- [GHJY15].Ge R, Huang F, Jin C, and Yuan Y Escaping from saddle points online stochastic gradient for tensor decomposition. In Conference on Learning Theory, pages 797–842, 2015. [Google Scholar]
- [GX16].Gao B and Xu Z Phase retrieval using Gauss-Newton method. arXiv preprint arXiv:1606.08135, 2016. [Google Scholar]
- [HH17].Huang W and Hand P Blind deconvolution by a steepest descent algorithm on a quotient manifold. arXiv preprint arXiv:1710.03309, 2017. [Google Scholar]
- [HZC18].Hao B, Zhang A, and Cheng G Sparse and low-rank tensor estimation via cubic sketchings. arXiv preprint arXiv:1801.09326, 2018. [DOI] [PMC free article] [PubMed] [Google Scholar]
- [JGN+17].Jin C, Ge R, Netrapalli P, Kakade SM, and Jordan MI How to escape saddle points efficiently. arXiv preprint arXiv:1703.00887, 2017. [Google Scholar]
- [JNJ17].Jin C, Netrapalli P, and Jordan MI Accelerated gradient descent escapes saddle points faster than gradient descent. arXiv preprint arXiv:1711.10456, 2017. [Google Scholar]
- [KMO10].Keshavan RH, Montanari A, and Oh S Matrix completion from a few entries. IEEE Transactions on Information Theory, 56(6):2980–2998, June 2010. [Google Scholar]
- [KRT17].Kueng R, Rauhut H, and Terstiege U Low rank matrix recovery from rank one measurements. Applied and Computational Harmonic Analysis, 42(1):88–116, 2017. [Google Scholar]
- [Lan93].Lang S Real and functional analysis. Springer-Verlag, New York, 10:11–13, 1993. [Google Scholar]
- [LGL15].Li G, Gu Y, and Lu YM Phase retrieval using iterative projections: Dynamics in the large systems limit. In Allerton Conference on Communication, Control, and Computing, pages 1114–1118. IEEE, 2015. [Google Scholar]
- [LL17].Lu YM and Li G Phase transitions of spectral initialization for high-dimensional nonconvex estimation. arXiv preprint arXiv:1702.06435, 2017. [Google Scholar]
- [LLSW18].Li X, Ling S, Strohmer T, and Wei K Rapid, robust, and reliable blind deconvolution via nonconvex optimization. Applied and Computational Harmonic Analysis, 2018. [Google Scholar]
- [LMCC18].Li Y, Ma C, Chen Y, and Chi Y Nonconvex matrix factorization from rank-one measurements. arXiv preprint arXiv:1802.06286, 2018. [Google Scholar]
- [LMZ17].Li Y, Ma T, and Zhang H Algorithmic regularization in over-parameterized matrix recovery. arXiv preprint arXiv:1712.09203, 2017. [Google Scholar]
- [LSJR16].Lee JD, Simchowitz M, Jordan MI, and Recht B Gradient descent converges to minimizers. arXiv preprint arXiv:1602.04915, 2016. [Google Scholar]
- [MM17].Mondelli M and Montanari A Fundamental limits of weak recovery with applications to phase retrieval. arXiv preprint arXiv:1708.05932, 2017. [Google Scholar]
- [MSK17].Murray R, Swenson B, and Kar S Revisiting normalized gradient descent: Evasion of saddle points. arXiv preprint arXiv:1711.05224, 2017. [Google Scholar]
- [MWCC17].Ma C, Wang K, Chi Y, and Chen Y Implicit regularization in nonconvex statistical estimation: Gradient descent converges linearly for phase retrieval, matrix completion and blind deconvolution. arXiv preprint arXiv:1711.10467, 2017. [Google Scholar]
- [MXM18].Ma J, Xu J, and Maleki A Optimization-based AMP for phase retrieval: The impact of initialization and ℓ2-regularization. arXiv preprint arXiv:1801.01170, 2018. [Google Scholar]
- [NJS13].Netrapalli P, Jain P, and Sanghavi S Phase retrieval using alternating minimization. Advances in Neural Information Processing Systems (NIPS), 2013. [Google Scholar]
- [NP06].Nesterov Y and Polyak BT Cubic regularization of Newton method and its global performance. Mathematical Programming, 108(1):177–205, 2006. [Google Scholar]
- [QZEW17].Qing Q, Zhang Y, Eldar Y, and Wright J Convolutional phase retrieval via gradient descent. Neural Information Processing Systems, 2017. [Google Scholar]
- [SCC18].Sur P, Chen Y, and Candès EJ The likelihood ratio test in high-dimensional logistic regression is asymptotically a rescaled chi-square. accepted to Probability Theory and Related Fields, 2018. [Google Scholar]
- [SEC+15].Shechtman Y, Eldar YC, Cohen O, Chapman HN, Miao J, and Segev M Phase retrieval with application to optical imaging: a contemporary overview. IEEE signal processing magazine, 32(3):87–109, 2015. [Google Scholar]
- [SJL17].Soltanolkotabi M, Javanmard A, and Lee JD Theoretical insights into the optimization landscape of over-parameterized shallow neural networks. arXiv preprint arXiv:1707.04926, 2017. [Google Scholar]
- [SL16].Sun R and Luo Z-Q Guaranteed matrix completion via non-convex factorization. IEEE Transactions on Information Theory, 62(11):6535–6579, 2016. [Google Scholar]
- [Sol14].Soltanolkotabi M Algorithms and Theory for Clustering and Nonconvex Quadratic Programming. PhD thesis, Stanford University, 2014. [Google Scholar]
- [Sol17].Soltanolkotabi M Structured signal recovery from quadratic measurements: Breaking sample complexity barriers via nonconvex optimization. arXiv preprint arXiv:1702.06175, 2017. [Google Scholar]
- [SQW16].Sun J, Qu Q, and Wright J A geometric analysis of phase retrieval. In Information Theory (ISIT), 2016 IEEE International Symposium on, pages 2379–2383. IEEE, 2016. [Google Scholar]
- [SS12].Schudy W and Sviridenko M Concentration and moment inequalities for polynomials of independent random variables. In Proceedings of the Twenty-Third Annual ACM-SIAM Symposium on Discrete Algorithms, pages 437–446. ACM, New York, 2012. [Google Scholar]
- [TBS+16].Tu S, Boczar R, Simchowitz M, Soltanolkotabi M, and Recht B Low-rank solutions of linear matrix equations via procrustes flow. In Proceedings of the 33rd International Conference on International Conference on Machine Learning-Volume 48, pages 964–973. JMLR. org, 2016. [Google Scholar]
- [TV17].Tan YS and Vershynin R Phase retrieval via randomized kaczmarz: Theoretical guarantees. arXiv preprint arXiv:1706.09993, 2017. [Google Scholar]
- [Ver12].Vershynin R Introduction to the non-asymptotic analysis of random matrices. Compressed Sensing, Theory and Applications, pages 210–268, 2012. [Google Scholar]
- [Wei15].Wei K Solving systems of phaseless equations via Kaczmarz methods: A proof of concept study. Inverse Problems, 31(12):125008, 2015. [Google Scholar]
- [WGE17].Wang G, Giannakis GB, and Eldar YC Solving systems of random quadratic equations via truncated amplitude flow. IEEE Transactions on Information Theory, 2017. [Google Scholar]
- [WGSC17].Wang G, Giannakis GB, Saad Y, and Chen J Solving almost all systems of random quadratic equations. arXiv preprint arXiv:1705.10407, 2017. [Google Scholar]
- [YYF+17].Yang Z, Yang LF, Fang EX, Zhao T, Wang Z, and Neykov M Misspecified nonconvex statistical optimization for phase retrieval. arXiv preprint arXiv:1712.06245, 2017. [Google Scholar]
- [ZB17].Zhong Y and Boumal N Near-optimal bounds for phase synchronization. arXiv preprint arXiv:1703.06605, 2017. [Google Scholar]
- [ZCL16].Zhang H, Chi Y, and Liang Y Provable non-convex phase retrieval with outliers: Median truncated Wirtinger flow. In International conference on machine learning, pages 1022–1031, 2016. [Google Scholar]
- [Zha17].Zhang T Phase retrieval using alternating minimization in a batch setting. arXiv preprint arXiv:1706.08167, 2017. [Google Scholar]
- [ZL16].Zheng Q and Lafferty J Convergence analysis for rectangular matrix completion using Burer-Monteiro factorization and gradient descent. arXiv preprint arXiv:1605.07051, 2016. [Google Scholar]
- [ZWGC17].Zhang L, Wang G, Giannakis GB, and Chen J Compressive phase retrieval via reweighted amplitude flow. arXiv preprint arXiv:1712.02426, 2017. [Google Scholar]
- [ZWL15].Zhao T, Wang Z, and Liu H A nonconvex optimization framework for low rank matrix estimation. In Advances in Neural Information Processing Systems, pages 559–567, 2015. [PMC free article] [PubMed] [Google Scholar]
- [ZZLC17].Zhang H, Zhou Y, Liang Y, and Chi Y A nonconvex approach for phase retrieval: Reshaped wirtinger flow and incremental algorithms. Journal of Machine Learning Research, 2017. [Google Scholar]
Associated Data
This section collects any data citations, data availability statements, or supplementary materials included in this article.








