Skip to main content
NIHPA Author Manuscripts logoLink to NIHPA Author Manuscripts
. Author manuscript; available in PMC: 2021 Apr 7.
Published in final edited form as: Math Program. 2019 Feb 4;176(1-2):5–37. doi: 10.1007/s10107-019-01363-6

Gradient Descent with Random Initialization: Fast Global Convergence for Nonconvex Phase Retrieval

Yuxin Chen *, Yuejie Chi , Jianqing Fan , Cong Ma
PMCID: PMC8025800  NIHMSID: NIHMS1053827  PMID: 33833473

Abstract

This paper considers the problem of solving systems of quadratic equations, namely, recovering an object of interest xn from m quadratic equations/samples yi=(aix)2,1im. 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 xn, but only have access to a few quadratic equations of the form

yi=(aix)2,1im, (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≤im take the form of either biaiβ1 or biaiβ2, without knowing which of the two vectors generates the data. In a simple symmetric case with β1 = β2 = x (so that bi±aix), the squared measurements yi=bi2(aix)2 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

minimizexnf(x):=14mi=1m[(aix)2yi]2. (2)

Under Gaussian designs where aii.i.dN(0,In), 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

xt+1=xtηtf(xt),t=0,1, (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 |aix0| is reasonably small for all 1 ≤ im — 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

xN(0,n1In)andx0N(0,n1In).

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. aii.i.d.N(0,In) for 1 ≤ im. The relative 2 errors dist(xt, x)/∥x2 of the GD iterates in a random trial are plotted in Figure 1, where

dist(xt,x):=min{xtx2,xt+x2} (4)

represents the 2 distance between xt and x modulo the unrecoverable global sign.

Figure 1:

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, xx and the orthogonal component xt − ⟨xt, xx, where we normalize x2=1 for simplicity. Denote by xt2 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, |xt,x|/xt2, grows exponentially fast throughout the execution of the algorithm, as demonstrated in Figure 2(a). This metric |xt,x|/xt2 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:

Figure 2:

(a) The ratio |xt,x|/xt2, and (b) the size |xt,x| 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 x2=1.

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 xn withx2 = 1. Suppose that aii.i.d.N(0,In) for 1 ≤ im, x0N(0,n1In), and ηtη=c/x22 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

dist(xt,x)γ(1ρ)tTγ,tTγ

for some absolute constant 0 < ρ < 1, provided that the sample size mn 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,
    dist(xTγ,x)γ
    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
    O(logn+log1ϵ).
    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 mn 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:

Figure 3:

The trajectory of (αt, βt), where αt = |⟨xt, x⟩| and βt =xt − ⟨xt, xx2 represent respectively the size of the signal component and that of the orthogonal component of the GD iterates (assume ∥x2 = 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

xt:=x1tandxt:=[xit]2in (5)

the first entry and the 2nd through the nth entries of xt, respectively. Since x = e1, it is easily seen that

xte1=xt,xxsignalcomponentand[0xt]=xtxt,xxorthogonalcomponent (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

αt:=xtandβt:=xt2. (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.

xt+1=xtηF(xt).

Here, ∇F(x) represents the population gradient given by

F(x):=(3x221)x2(xx)x,

which can be computed by F(x)=E[f(x)]=E[{(aix)x2(aix)2}aiaix] assuming that x and the ai’s are independent. Simple algebraic manipulation reveals the dynamics for both the signal and the orthogonal components:

xt+1={1+3η(1xt22)}xt; (8a)
xt+1={1+η(13xt22)}xt. (8b)

Assuming that η is sufficiently small and recognizing that xt22=αt2+βt2, we arrive at the following population-level state evolution for both αt and βt (cf. (7)):

αt+1={1+3η[1(αt2+βt2)]}αt; (9a)
βt+1={1+η[13(αt2+βt2)]}βt. (9b)

This recursive system has three fixed points:

(α,β)=(1,0),(α,β)=(0,0),and(α,β)=(0,1/3),

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 αtt 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 x0N(0,n1In). Figure 4 displays the dynamics of αtt, αt, and βt, which are precisely as discussed above.

Figure 4:

Figure 4:

Population-level state evolution, plotted semilogarithmically: (a) the ratio αtt vs. iteration count, and (b) αt and βt vs. iteration count. The results are shown for n = 1000, ηt ≡ 0.1, and x0N(0,n1In) (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

xt+1=xtηf(xt)=xtηF(xt)η(f(xt)F(xt)):=r(xt), (10)

where f(x)=m1i=1m[(aix)2(aix)2]aiaix. 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

xt+1=xtη(F(xt))1ηr1(xt),

where

r1(x):=1mi=1m[(aix)3ai,12(aix)]ai,1E[{(aix)3ai,12(aix)}ai,1] (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 ∥xt2 = O(1), one can apply the CLT to demonstrate that

|r1(xt)|Var(r1(xt))polylog(m)polylog(m)m (12)

with high probability, which is often negligible compared to the other terms. For instance, for the random initial guess x0N(0,n1In) one has |x0|1/nlogn with probability approaching one, telling us that

|r1(x0)|polylog(m)m|x0|

as long as mn poly log(m). This combined with the fact that |x0η(F(x0))1||x0| reveals |r1(x0)||x0η(F(x0))1|. Similar observations hold true for the orthogonal component xt.

In summary, by assuming independence between xt and {ai}, we arrive at an approximate state evolution for the finite-sample regime:

αt+1{1+3η[1(αt2+βt2)]}αt; (13a)
βt+1{1+η[13(αt2+βt2)]}βt, (13b)

with the proviso that mn 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 |r1(xt)||xt| for all t ≥ 0. In particular, in the beginning iterations, |xt| is as small as O(1/n). 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:

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 |xt|/5(or|x,x|/5).

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

  1. independent of certain components of the design vectors {ai}; and

  2. 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:

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 {aisgn}, where aisgn is obtained by randomly flipping the sign of the first entry of ai; (d) {xt,sgn,(l)} is constructed by discarding the lth sample {alsgn,yl}.

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

O(L[min(θ,γ2/ρ)]2+βαlog1ϵ)=O(n3+nlog1ϵ)

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

O(L1/2ρ1/4[min(θ,γ2/ρ)]7/4)=O(n2.5).

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. Ln 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 xn. Suppose aii.i.d.N(0,In)(1im) and m ≥ Cn log13m for some sufficiently large constant C > 0. Assume that the initialization x0 is independent of {ai} and obeys

|x0,x|x221nlognand(11logn)x2x02(1+1logn)x2, (14)

and that the stepsize satisfies ηtη=c/x22 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),

  1. the GD iterates (3) converge linearly to x after tTγ, namely,
    dist(xt,x)(1η2x22)tTγγx2,tTγ;
  2. the strength ratio of the signal component xt,xx22x to the orthogonal component xtxt,xx22x obeys
    xt,xx22x2xtxt,xx22x21nlogn(1+c1η2)t,t=0,1, (15)
    for some constant c1 > 0.

Several remarks regarding Theorem 2 are in order.

  • Our current sample complexity reads mn 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 x0N(0,n1x22In) obeys the condition (14) with probability exceeding 1O(1/logn), 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

x0=1mi=1myiu,

where u is uniformly distributed over the unit sphere. With probability at least 1O(1/logn) 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

x=e1andx10>0. (16)

Given this, one can decompose

xt=xte1+[0xt] (17)

where xt=x1t and xt=[xit]2in as introduced in Section 2. For notational simplicity, we define

αt:=xtandβt:=xt2. (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

dist(xt,x)xtx2|αt1|+|βt|γ.

Therefore, our first step — which is concerned with proving (xt,x)γ — comes down to the following two steps.

  1. Show that if αt and βt satisfy the approximate state evolution (see (13)), then there exists some Tγ = O (log n) such that
    |αTγ1|γ/2andβTγγ/2, (19)
    which would immediately imply that
    dist(xTγ,x)γ.
    Along the way, we will also show that the ratio αtt grows exponentially fast.
  2. Justify that αt and βt satisfy the approximate state evolution with high probability, using (some variants of) leave-one-out arguments.

After tTγ, we can invoke prior theory [MWCC17] concerning local convergence to show that with high probability,

dist(xt,x)(1ρ)tTγxTγx2,t>Tγ

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

αt+1={1+3η[1(αt2+βt2)]+ηζt}αt (20a)
βt+1={1+η[13(αt2+βt2)]+ηρt}βt, (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

α01nlognand11lognα02+β021+1logn. (21)

and the perturbation terms satisfy

max{|ζt|,|ρt|}c3logn,t=0,1,

for some sufficiently small constant c3 > 0.

(a) Let

Tγ:=min{t:|αt1|γ/2andβtγ/2}. (22)

Then for any sufficiently large n and m and any sufficiently small constant η > 0, one has

Tγlogn, (23)

and there exist some constants c5, c10 > 0 independent of n and m such that

12nlognαt2,c5βt1.5andαt+1/αtβt+1/βt1+c10η2,0tTγ. (24)

(b) If we define

T0:=min{t:αt+1c6/log5m}, (25)
T1:=min{t:αt+1>c4}, (26)

for some arbitrarily small constants c4, c6 > 0, then

  1. T0 T1 Tγ ≲ log n; T1 T0 ≲ log log m; Tγ T1 ≲ 1;

  2. For T0 < tTγ, one has αtc6/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 α01/n 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 αtt.

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 ≤ tT0;

  • Phase II: consider all iterations with T0 < tTγ.

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

xt+1={1+3η(1xt22)}xtηr1(xt),

where the perturbation term r1(xt) obeys

r1(xt)=[1(xt)2]xt(1mi=1mai,143):=I1+[13(xt)2]1mi=1mai,13ai,xt:=I23xt(1mi=1m(ai,xt)2ai,12xt22):=I31mi=1m(ai,xt)3ai,1:=I4. (27)

Here and throughout the paper, for any vector vn, vn1 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 O(1/(npolylog(n))). This precludes us from seeking a uniform bound on the function h(x):=m1i=1m(ai,x)3ai,1 over all x (or even all x within the set C incoherent with {ai}), since the uniform bound supxC|h(x)| can be O(n/polylog(n)) times larger than the desired order.

Algorithm 1.

The lth leave-one-out sequence

Input: {ai}1≤im,il, {yi}1≤im,il, and x0.
Gradient updates: for t = 0, 1, 2, …, T − 1 do
xt+1,(l)=xt,(l)ηtf(l)(xt,(l)), (29)
where x0,(l) = x0 and f(l)(x)=(1/4m)i:il[(aix)2(aix)2]2.

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

I4=1mi=1m(ai,xt)3|ai,1|ξi

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:

  1. Construct a sequence {xt,sgn} independent of {ξi} obeying xt,sgnxt, so that
    I41mi=1m(ai,xt,sgn)3|ai,1|:=wiξi.
    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.
  2. Demonstrate that the weight wi is well-controlled, or equivalently, |ai,xt,sgn|(1im) 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)xtxt,sgn, followed by the argument:
    |ai,xt,sgn||ai,xt||ai,xt,(i)|logmxt,(i)2logmxt2. (28)
    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 ≤ im.

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 ≤ lm, we introduce a sequence {xt,(l)}, which drops the lth sample and runs GD w.r.t. the auxiliary objective function
    f(l)(x)=14mi:il[(aix)2(aix)2]2. (32)
    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 |alxt,(l)|logmxt,(l)2. Such incoherence properties further allow us to control both |alxt| and |alxt,sgn| (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.

Algorithm 2.

The random-sign sequence

Input: {|ai,1|}1≤im, {ai,}1≤im, {ξisgn}1im, {yi}1≤im, x0.
Gradient updates: for t = 0, 1, 2, …, T − 1 do
xt+1,sgn=xt,sgnηtfsgn(xt,sgn), (30)
where x0,sgn=x0,fsgn(x)=14mi=1m[(aisgnx)2(aisgnx)2]2 with aisgn:=[ξisgn|ai,1|ai,].

Algorithm 3.

The lth leave-one-out and random-sign sequence

Input: {|ai,1|}1≤im,il, {ai,}1≤im,il, {ξisgn}1im,,il, {yi}1≤im,il, x0.
Gradient updates: for t = 0, 1, 2, …, T − 1 do
xt+1,sgn,(l)=xt,sgn,(l)ηtfsgn,(l)(xt,sgn,(l)), (31)
where x0,sgn,(l)=x0,fsgn,(l)(x)=14mi:il[(aisgnx)2(aisgnx)2]2 with aisgn:=[ξisgn|ai,1|ai,].
  • Random-sign sequence {xt,sgn}t≥0. Introduce a collection of auxiliary design vectors {aisgn}1im defined as
    aisgn:=[ξisgn|ai,1|ai,], (33)
    where {ξisgn}1im is a set of Rademacher random variables independent of {ai}, i.e.
    ξisgn=i.i.d.{1,withprobability1/2,1,else1im. (34)
    In words, aisgn is generated by randomly flipping the sign of the first entry of ai. To simplify the notations hereafter, we also denote
    ξi=sgn(ai,1). (35)
    As a result, ai and aisgn 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
    fsgn(x)=14mi=1m[(aisgnx)2(aisgnx)2]2. (36)
    One simple yet important feature associated with these new design vectors is that it produces the same measurements as {ai}:
    (aix)2=(aisgnx)2=|ai,1|2,1im. (37)
    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.
  • 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 {aisgn} and discarding a single sample (alsgn,ylsgn).. 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,

x0=x0,(l)=x0,sgn=x0,sgn,(l),1lm. (38)

4.5. Justification of approximate state evolution for Phase I of Stage 1

Recall that Phase I consists of the iterations 0 ≤ tT0, where

T0=min{t:αt+1c6log5m}. (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.

max1lmxtxt,(l)2βt(1+1logm)tC1nlog5mm, (40a)
max1lm|xtxt,(l)|αt(1+1logm)tC2nlog12mm, (40b)
xtxt,sgn2αt(1+1logm)tC3nlog5mm, (40c)
max1lmxtxt,sgnxt,(l)+xt,sgn,(l)2αt(1+1logm)tC4nlog9mm, (40d)
c5xt2xt2C5, (40e)
xt24αtnlogm, (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 mCn log11 m for some sufficiently large constant C > 0. For any 0 ≤ tT0 (cf. (39)), if the tth iterates satisfy the induction hypotheses (40), then with probability at least 1 − O(me−1.5n) − O(m−10),

αt+1={1+3η[1(αt2+βt2)]+ηζt}αt; (41a)
βt+1={1+η[13(αt2+βt2)]+ηρt}βt (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 ≤ tT0. Before proceeding to this induction step, it is helpful to first develop more understanding about the preceding hypotheses.

  1. 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 xtxt,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 ∥xt2.

  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, |xtxt,(l)|, ∥xtxt,sgn2 and ∥xtxt,sgnxt,(l)+xt,sgn,(l)2 grow more or less at the same rate as αt (modulo some (1+1/logm)T0 factor). In contrast, ∥xtxt,(l)∥2 shares the same growth rate with βt (modulo the (1+1/logm)T0 factor). See Figure 7 for an illustration. The difference in the growth rates turns out to be crucial in establishing the advertised result.

  3. 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 α11/n and β1 ≍ 1, one sees that x1x1,(l)21/m, |x1x1,(l)|1/m, x1x1,sgn21/m and ∥x1x1,sgnx1,(l)+x1,sgn,(l)2 ≲ 1/m. See Figure 7 for an illustration of the trends of the above four quantities.

Figure 7:

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 x2=1. (a) The four differences increases in Stage 1. From the induction hypotheses (40), our upper bounds on |xtxt,(l)|, ∥xtxt,sgn2 and ∥xtxt,sgnxt,(l) + xt,sgn,(l)2 scale linearly with αt, whereas the upper bound on ∥xtxt,(l)2 is proportional to βt. In addition, x1x1,(l)21/m, |x1x1,(l)|1/m, x1x1,sgn21/m and ∥x1x1,sgnx1,(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}, {aisgn} are immediate, as summarized in the following lemma.

Lemma 3

Suppose that mCn log6m for some sufficiently large constant C > 0 and the tth iterates satisfy the induction hypotheses (40) for tT0, then with probability at least 1 − O(me−1.5n) − O(m−10),

max1lm|alxt|logmxt2;max1lm|al,xt|logmxt2;max1lm|alxt,sgn|logmxt,sgn2;max1lm|al,xt,sgn|logmxt,sgn2;max1lm|alsgnxt,sgn|logmxt,sgn2.

Proof. These incoherence conditions typically arise from the independence between {xt,(l)} and al. For instance, the first line follows since

|alxt||alxt,(l)|logmxt,(l)2logmxt2.

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 ≤ tT0. 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 tT0, 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 mCnlog5 m for some sufficiently large constant C > 0. If the induction hypotheses (40) hold true up to the tth iteration for some tT0, then with probability at least 1−O(me−1.5n)−O(m−10),

max1lmxt+1xt+1,(l)2βt+1(1+1logm)t+1C1nlog5mm (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 mCnlog6 m for some sufficiently large constant C > 0. If the induction hypotheses (40) hold true up to the tth iteration for some tT0, then with probability at least 1−O(me−1.5n)−O(m−10),

max1lm|xt+1xt+1,(l)|αt+1(1+1logm)t+1C2nlog12mm (44)

holds as long as η > 0 is a sufficiently small constant and C2C4.

Proof. See Appendix E. □

Regarding the difference between xt and xt,sgn (see (40c)), we have the following result.

Lemma 6

Suppose mCnlog5 m for some sufficiently large constant C > 0. If the induction hypotheses (40) hold true up to the tth iteration for some tT0, then with probability at least 1−O(me−1.5n)−O(m−10),

xt+1xt+1,sgn2αt+1(1+1logm)t+1C3nlog5mm (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+1xt+1,sgnxt+1,(l) + xt+1,sgn,(l) (cf. (40d)), for which one has the following lemma.

Lemma 7

Suppose mCnlog8 m for some sufficiently large constant C > 0. If the induction hypotheses (40) hold true up to the tth iteration for some tT0, then with probability at least 1−O(me−1.5n)−O(m−10),

max1lmxt+1xt+1,sgnxt+1,(l)+xt+1,sgn,(l)2αt+1(1+1logm)t+1C4nlog9mm (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 tT0, 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 < tTγ (see the definition of T0 in Lemma 1), for which one has

αtc6log5m (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 < tTγ.

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.

max1lmxtxt,(l)2αt(1+1logm)tC6nlog15mm; (48a)
c5xt2xt2C5. (48b)

A direct consequence of (48) is the incoherence between xt and {al}, namely,

max1lm|al,xt|logmxt2; (49a)
max1lm|alxt|logmxt2. (49b)

To see this, one can use the triangle inequality to show that

|al,xt||al,xt,(l)|+|al,(xtxt,(l))|(i)logmxt,(l)2+nxtxt,(l)2logm(xt2+xtxt,(l)2)+nxtxt,(l)2(ii)logm+nlog15mmnlogm,

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 tTγ ≲ log n and mn log15/2m. This combined with the fact that xt2c5/2 results in

max1lm|al,xt|logmxt2. (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 mCnlog13 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),

αt+1={1+3η[1(αt2+βt2)]+ηζt}αt; (51a)
βt+1={1+η[13(αt2+βt2)]+ηρt}βt, (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≤lmxt+1xt+1,(l)2 (see (48a)).

Lemma 9

Suppose mCnlog5 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),

max1lmxt+1xt+1,(l)2αt+1(1+1logm)t+1C6nlog13mm

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

max1lmxT0+1xT0+1,(l)2βT0+1(1+1logm)T0+1C1nlog5mmαT0+1(1+1logm)T0+1C6nlog15mm,

for some constant condition C6 ≫ 1, where the second line holds since βT0+1C5, αT0+1c6/log5m.

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. tTγ. In addition to (xTγ,x)γ, we can also see from (49b) that

max1im|aixTγ|logm,

which in turn implies that

max1im|ai(xTγx)|logm.

Armed with these properties, one can apply the arguments in [MWCC17, Section 6] to prove that for tTγ + 1,

dist(xt,x)(1η2)tTγdist(xTγ,x)(1η2)tTγγ. (52)

Notably, the theorem therein [MWCC17, Theorem 1] works under the stepsize ηtηc/log n when mn log n. Nevertheless, as remarked by the authors, when the sample complexity exceeds mn log3m, a constant stepsize is allowed.

We are left with proving (15) for Stage 2. Note that we have already shown that the ratio αtt increases exponentially fast in Stage 1. Therefore,

αT1βT112nlogn(1+c10η2)T1

and, by the definition of T1 (see (26)) and Lemma 1, one has αT1βT11 and hence

αT1βT11. (53)

When it comes to t > Tγ, in view of (52), one has

αtβt1dist(xt,x)dist(xt,x)1γ(1η2)tTγγ1γγ(1+η2)tTγ(i)αT1βT1(1+η2)tTγ1nlogn(1+c10η2)T1(1+η2)tTγ(ii)1nlogn(1+c10η2)Tγ(1+η2)tTγ1nlogn(1+c10η2)t,

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 αtt.

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 mn 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. mn) 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:

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

supp

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

1

An iterative algorithm is said to enjoy linear convergence if the iterates {xt} converge geometrically fast to the minimizer x.

2

Here, we do not take the absolute value of xt. As we shall see later, the xt‘s are of the same sign throughout the execution of the algorithm.

3

More specifically, the GD update xt+1=xtm1ηti=1m[(aixt)2yi]aiaixt(I+m1ηti=1myiaiai)xt when xt ≈ 0, which is equivalent to a power iteration (without normalization) w.r.t. the data matrix I+m1ηti=1myiaiai.

4

When applied to phase retrieval with mn poly log n, one has Ln, ρn, θγ ≍ 1 (see [SQW16, Theorem 2.2]), α ≍ 1, and βn (ignoring logarithmic factors).

5

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.

Supplementary Materials

supp

RESOURCES