Oracle Complexity of Second-Order Methods for Smooth Convex Optimization
Yossi Arjevani, Ohad Shamir, Ron Shiff

TL;DR
This paper establishes tight bounds on the number of iterations second-order methods need to optimize smooth convex functions, clarifying their advantages and limitations compared to gradient-based methods.
Contribution
It provides the first tight bounds on the oracle complexity of second-order methods for smooth convex optimization, including higher-order generalizations.
Findings
Second-order methods can match or outperform gradient methods under certain conditions.
Tight bounds reveal when second-order methods are advantageous or limited.
Results extend to higher-order optimization techniques.
Abstract
Second-order methods, which utilize gradients as well as Hessians to optimize a given function, are of major importance in mathematical optimization. In this work, we prove tight bounds on the oracle complexity of such methods for smooth convex functions, or equivalently, the worst-case number of iterations required to optimize such functions to a given accuracy. In particular, these bounds indicate when such methods can or cannot improve on gradient-based methods, whose oracle complexity is much better understood. We also provide generalizations of our results to higher-order methods.
Peer Reviews
No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.
Videos
No videos yet. Explain this paper in a talk, walkthrough, or lecture? Add one.
Oracle Complexity of Second-Order Methods
for Smooth Convex Optimization
Yossi Arjevani Ohad Shamir Ron Shiff
Department of Computer Science and Applied Mathematics
Weizmann Institute of Science
{yossi.arjevani,ohad.shamir}@weizmann.ac.il
Abstract
Second-order methods, which utilize gradients as well as Hessians to optimize a given function, are of major importance in mathematical optimization. In this work, we prove tight bounds on the oracle complexity of such methods for smooth convex functions, or equivalently, the worst-case number of iterations required to optimize such functions to a given accuracy. In particular, these bounds indicate when such methods can or cannot improve on gradient-based methods, whose oracle complexity is much better understood. We also provide generalizations of our results to higher-order methods.
1 Introduction
We consider an unconstrained optimization problem of the form
[TABLE]
where is a generic smooth and convex function. A natural and fundamental question is how efficiently can we optimize such functions.
We study this question through the well-known framework of oracle complexity (Nemirovsky and Yudin, 1983), which focuses on iterative methods relying on local information. Specifically, it is assumed that the algorithm’s access to the function is limited to an oracle, which given a point , returns the values and derivatives of the function at . This naturally models standard optimization approaches to unstructured problems such as Eq. (1), and allows one to study their efficiency, by bounding the number of oracle calls required to reach a given optimization error. Different classes of methods can be distinguished by the type of oracle they use. For example, gradient-based methods (such as gradient descent or accelerated gradient descent) rely on a first-order oracle, which returns gradients, whereas methods such as the Newton method rely on a second-order oracle, which returns gradients as well as Hessians.
The theory of first-order oracle complexity is quite well developed (Nemirovsky and Yudin, 1983; Nesterov, 2004; Nemirovski, 2005). For example, if the dimension is unrestricted, in Eq. (1) has -Lipschitz gradients, and the algorithm makes its first oracle query at a point , then the worst-case number of queries required to attain a point satisfying is
[TABLE]
where is an upper bound on the distance between and the nearest minimizer of . Moreover, if the function is also -strongly convex for some 111Assuming is twice-differentiable, this corresponds to uniformly for all ., then the oracle complexity bound is
[TABLE]
Both bounds are achievable using accelerated gradient descent (Nesterov, 1983).
However, these bounds do not capture the attainable performance of second-order methods, which rely on gradient as well as Hessian information. This is a central class of optimization methods, including the well-known Newton method and its many variants. Clearly, since these methods rely on Hessians as well as gradients, their oracle complexity can only be better than first-order methods. On the flip side, the per-iteration computational complexity is generally higher, in order to process the additional Hessian information (especially in high-dimensional problems where the Hessian matrix may be very large). Thus, it is natural to ask how much does this added per-iteration complexity pay off in terms of oracle complexity.
To answer this question, one needs good oracle complexity lower bounds for second-order methods, which establish the limits of attainable performance using any such algorithm. Perhaps surprisingly, such results do not seem to currently exist in the literature, and clarifying the oracle complexity of such methods was posed as an important open question (see for example Nesterov, 2008). The goal of this paper is to address this gap.
Specifically, we prove that when the dimension is sufficiently large, for the class of convex functions with -Lipschitz gradients and -Lipschitz Hessians, the worst-case oracle complexity of any deterministic algorithm is
[TABLE]
This bound is tight up to constants, as it is matched by a combination of existing methods in the literature (see discussion below). Moreover, if we restrict ourselves to functions which are -strongly convex, we prove an oracle complexity lower bound of
[TABLE]
Moreover, we establish that this bound is tight up to logarithmic factors (independent of ), utilizing a novel adaptation of the A-NPE algorithm proposed in Monteiro and Svaiter (2013) (see Appendix A). These new lower bounds have several implications:
- •
Perhaps unexpectedly, Eq. (5) establishes that one cannot avoid in general a polynomial dependence on geometry-dependent “condition numbers” of the form or , even with second-order methods. This is despite the ability of such methods to favorably alter the geometry of the problem (for example, the Newton method is well-known to be affine invariant).
- •
To improve on the oracle complexity of first-order methods for strongly-convex problems (Eq. (3)) by more than logarithmic factors, one cannot avoid a polynomial dependence on the initial distance to the optimum. This is despite the fact that the dependence on with first-order methods is only logarithmic. In fact, when is sufficiently large (of order or larger), second-order methods cannot improve on the oracle complexity of first-order methods by more than logarithmic factors.
- •
In the convex case, second-order methods are again no better than first-order methods in certain parameter regimes (i.e., when ), despite the availability of more information.
Finally, we show how our proof techniques can be generalized, to establish lower bounds for methods employing higher-order derivatives. In particular, for methods using all derivatives up to order , we show that for convex functions with -Lipschitz k-th order derivatives, the oracle complexity is
[TABLE]
Note that this directly generalizes Eq. (2) for , and Eq. (4) when and is unrestricted.
Related Work
Below, we review some pertinent results in the context of second-order methods. Related results in the contest of k-th order methods are discussed in Subsection 2.2.
Perhaps the most well-known and fundamental second-order method is the Newton method, which relies on iterations of the form (see e.g., Boyd and Vandenberghe (2004)). It is well-known that this method exhibits local quadratic convergence, in the sense that if is strictly convex, and the method is initialized close enough to the optimum , then iterations suffice to reach a solution such that . However, in order to get global convergence (starting from an arbitrary point not necessarily close to the optimum), one needs to make some algorithmic modifications, such as introducing a step size parameter or line search, employing trust region methods, or adding various types of regularization (see for example Conn et al. (2000) and references therein). Despite the huge literature on the subject, the worst-case global convergence behavior of these methods is not well understood (Nesterov and Polyak, 2006). For the Newton method with a line search, the number of iterations can be upper bounded by
[TABLE]
where are the Lipschitz parameters of the gradients and Hessians respectively, and assuming the function is -strongly convex (Kantorovich (1948), see also Boyd and Vandenberghe (2004)). Note that the first term captures the initial phase required to get sufficiently close to , whereas the second term captures the quadratically convergent phase. Although the final convergence is rapid, the first phase is the dominant one in the bound (unless is exceedingly small). If is self-concordant222That is, for any vectors , the function satisfies , this can be improved to
[TABLE]
independent of the strong convexity and Lipschitz parameters (Nesterov and Nemirovskii (1994)). Unfortunately, not all practically relevant objective functions are self-concordant. For example, loss functions common in machine learning applications, such as the logistic loss , are not self-concordant333These can often be made self-concordant by re-scaling, smoothing and adding regularization (e.g. Bach (2010)), but even when possible, these modifications strongly affect the term in the bound, and prevents it from being independent of the strong convexity and Lipschitz parameters., and our own results utilize the simple but not self-concordant function .
Returning to our setting of generic convex and smooth functions, and focusing on strongly convex functions for now, the best existing upper bounds (we are aware of) were obtained for cubic-regularized variants of the Newton method, where at each iteration one essentially minimizes a quadratic approximation of the function at the current point, regularized by a cubic term (Nesterov and Polyak, 2006; Nesterov, 2008). The existing analysis (in section 6 of Nesterov (2008)) implies an oracle complexity bound of at most
[TABLE]
where is the distance from the initialization point to the optimum (see section 6 in Nesterov (2008), as well as Cartis et al. (2012) for another treatment of such cubic-regularized methods). However, as we show in Appendix A, a better oracle complexity bound can be obtained, by adapting the A-NPE method proposed in (Monteiro and Svaiter, 2013) and analyzed for convex functions, to the strongly convex case. The resulting complexity upper bound is
[TABLE]
An alternative to the above is to use a hybrid scheme, starting with accelerated gradient descent (which is an optimal first-order method for strongly convex functions with Lipschitz gradients) and when close enough to the optimal solution, switch to a cubic-regularized Newton method, which is quadratically converging in that region444Instead of cubic-regularized Newton, one can also use the standard Newton method, although the resulting bound using the existing analysis will have slightly worse logarithmic factors.. The required number of iterations is then
[TABLE]
where (see Nesterov (2004, 2008)). Clearly, by taking the best of Eq. (6) and Eq. (7) (depending on the parameters), one can theoretically attain an oracle complexity which is the minimum of Eq. (6) and Eq. (7). This minimum matches (up to a logarithmic factors) the lower bound in Eq. (5), which we establish in this paper.
It is interesting to note that the bounds in Eq. (6) and Eq. (7) are not directly comparable: The first bound has a polynomial dependence on and , and a logarithmic dependence on , whereas the second bound has a polynomial dependence on , logarithmic dependence on , and a logarithmic dependence on . In a rather wide parameter regime (e.g. when is reasonably large, as often occurs in practice), the bound of the hybrid scheme can be better than that of pure second-order methods. In light of this, Nesterov (2008) raised the question of whether second-order schemes are indeed useful at the initial stage of the optimization process, for these types of problems. Our results indicate that indeed, in certain parameter regimes, this is not the case.
Analogous results can be obtained for convex (not necessarily strongly convex) smooth functions. Using an appropriate analysis of the accelerated cubic-regularized Newton method (Nesterov, 2008), one can attain a bound of
[TABLE]
More recently, Monteiro and Svaiter (2013) proposed an accelerated hybrid proximal extragradient method, denoted as A-NPE, which attains a better bound of
[TABLE]
In addition, using an optimal first-order method (such as accelerated gradient descent), one can attain a bound of
[TABLE]
Clearly, by taking the best of the last two approaches (depending on the problem parameters), one can attain an oracle complexity equal to the minimum of the two bounds in Eq. (8) and Eq. (9). This is matched (up to constants) by the lower bound in Eq. (4), which we establish in this paper.
Finally, we discuss the few existing lower bounds known for second-order methods. If is not bounded (i.e.,the Hessians are not Lipschitz), it is easy to show that Hessian information is not useful. Specifically, the lower bound of Eq. (2) for first-order methods will then also apply to second-order methods, and in fact, to any method based on local information (see Nemirovsky and Yudin (1983, section 7.2.6) and Arjevani and Shamir (2016b)). Of course, this lower bound does not apply to second-order methods when is bounded. In our setting, it is also possible to prove an lower bound, even in one dimension (Nemirovsky and Yudin, 1983, section 8.1.1), but this does not capture the dependence on the strong convexity and Lipschitz parameters. Some algorithm-specific lower bounds in the context of non-convex optimization are provided in Cartis et al. (2010). Finally, we were recently informed of a new work (Agarwal and Hazan (2017), yet unpublished at the time of writing), which uses a clean and elegant smoothing approach, to derive second- and higher-order oracle lower bounds directly from known first-order oracle lower bounds, as well as extensions to randomized algorithms. However, the resulting bounds are not as tight as ours.
2 Main Results
In this section, we formally present our main results, starting with second-order oracle complexity bounds (Subsection 2.1), and then discussing extensions to higher-order oracles (Subsection 2.2).
2.1 Second-order Oracle
We consider a second-order oracle, which given a point returns the function’s value , its gradient and its Hessian , and algorithms, which produce a sequence of points , with each being some deterministic function of the oracle’s responses at . Our main results (for strongly convex and convex functions respectively) are provided below.
Theorem 1**.**
For any positive such that and (for some positive universal constants ), and any algorithm as above with initialization point , there exists a function (for some finite ) such that
- •
* is -strongly convex, twice-differentiable, has -Lipschitz gradients and -Lipschitz Hessians, and has a global minimum satisfying .*
- •
The index required to ensure is at least
[TABLE]
for some universal constant .
Theorem 2**.**
For any positive and any algorithm as above with initialization point , there exists a function (for some finite ) such that
- •
* is convex, twice-differentiable, has -Lipschitz gradients and -Lipschitz Hessians, and has a global minimum satisfying .*
- •
The index required to ensure is at least
[TABLE]
for some universal constant .
We emphasize that the theorems focus on the high-dimensional setting, where the dimension is not necessarily fixed and may depend on other problem parameters. Also, we note that the parameter constraints in Thm. 1 are purely for technical reasons (they imply that the different terms in the bound are at least some positive constant), and can probably be relaxed somewhat.
Let us compare these theorems to the upper bounds discussed in the related work section, which are
[TABLE]
in the strongly convex case, and
[TABLE]
in the convex case. Our bound in the convex case is tight up to constants, and in the strongly convex case, up to a factor. We conjecture that some such logarithmic factor (possibly a smaller one) is indeed necessary, in order to get a tight interpolation to the lower bound of first-order methods as (see Nemirovsky and Yudin (1983, section 7.2.6) and Arjevani and Shamir (2016b)), and that it can be recovered with a more careful analysis of our construction. However, this involves some non-trivial technical challenges, which we leave to future work.
Comparing the lower and upper bounds in the strongly convex case, one can make the following observations:
- •
The lower bound captures the two phases common in second-order methods such as the Newton method: An initial slow convergence from the initialization point to the local neighborhood of the optimum (captured by the term), followed by a fast local quadratic convergence to the optimum (captured by the second term, which is doubly-logarithmic in the accuracy ).
- •
Unless is exceedingly small, the oracle complexity is dominated by the geometry-dependent terms and . This is despite the fact that second-order methods can use Hessian information to alter the geometry of the problem (for example, the Newton method is well-known to be affine invariant).
- •
If is sufficiently large (specifically, if is order of or larger), then the lower bound becomes at least , which is no betters what can be obtained with first-order methods up to logarithmic factors (see Eq. (3)). Since often scales inversely with the strong convexity of the problem (e.g. since the strong convexity is due to a regularization term), this is a rather broad and reasonable regime.
- •
On the other hand, if is smaller than , then the oracle complexity can be significantly better than that of first-order methods, but this still comes at the inevitable price of a polynomial dependence on the distance from the optimum. In contrast, first-order methods have only a logarithmic dependence on (see Eq. (3)).
Similar types of conclusions regarding on the behavior of first and second-order methods can be drawn as in the strongly convex case. Namely, if is large enough (specifically, if ), the complexity of second-order methods is not significantly better than what can be obtained with first-order methods.
2.2 Higher Order Oracles
In addition to first-order and second-order oracles, it is of interest to understand what can be achieved with methods employing higher order derivatives. It turns out that the techniques we use to establish our second-order lower bounds can be easily generalized to such higher-order methods.
More explicitly, we consider methods which can be modelled as interacting with a k-th order oracle, which given a point returns the function’s value and all of its derivatives up to order , namely, . Given access to such an oracle, the method produces a sequence of points as before (where each is a deterministic function of the previous oracle responses). For simplicity, we will focus here on the case of convex functions (not necessarily strongly convex), where the -th order derivative is Lipschitz continuous.
Theorem 3**.**
For any positive integer , positive , and algorithm based on a -th order oracle as above, there exists a function (for some finite ) such that
- •
* is convex, times differentiable, -order smooth (i.e., ) and has a global minimum satisfying .*
- •
The index required to ensure is at least
[TABLE]
for some universal constant .
Note that this result directly generalizes existing results for first-order oracles (), as well as our results for second-order oracles (, when is unrestricted).
Finally, we compare our lower bound to the best upper bound we are aware of, established by Baes (2009) using a high-order method with oracle complexity of
[TABLE]
Note that the upper bound contains an additional term, and moreover, the exponent (as a function of ) is larger than ours ( vs. ). Based on our results, we know that this upper bound is loose in the case, so we conjecture that it is indeed loose for all , and can be improved.
3 Proof Ideas
The proofs of our theorems are based on a careful modification of a standard lower bound construction for first-order methods (see Nesterov (2004)). That construction uses quadratic functions, which in the convex case and ignoring various parameters, have a basic structure of the form
[TABLE]
(more precisely, one considers for a certain orthogonal matrix , and use additional parameters depending on the smoothness). A crucial ingredient of the proof is that the function has a value and derivative of zero at the origin, which allows us to construct a function which “hides” information from an algorithm relying solely on values and gradients. This can be shown to lead to an optimization error lower bound of the form after oracle queries, which for first-order methods leads to an lower bound on the error, translating to an lower bound on . However, this construction leads to trivial bounds for second-order methods, since given the Hessian and a gradient of a quadratic function at just a single point, one can already compute the exact minimizer.
Our approach to handle second-order (and more generally, -order) methods is quite simple: Instead of , we rely on mappings of the form , and use functions with the basic structure
[TABLE]
The intuition is that has a value and first k derivatives of zero at the origin, and therefore variants of the function above can be used to “hide” information from the algorithm, even if it can receive Hessians or higher-order derivatives of the function. Another motivation for choosing such functions is that they are generally not self-concordant, and therefore the upper bounds relevant to self-concordant functions do not apply. We rely on this construction and arguments similar to those of first-order oracle lower bounds, to get our results.
In the derivation of our results for second-order methods, there are two technical challenges that need to be overcome: The first is that , as defined above (for ), can be shown to have globally Lipschitz Hessians, but not globally Lipschitz gradients as required by our theorems. To tackle this, we replace the mapping by a more complicated mapping, which is cubic close to the origin and quadratic further away. This necessarily complicates the proof. The second challenge is that due to the cubic terms, computing the minimizer of and its minimal value is more challenging than in first-order lower bounds, especially in the strongly convex case (where we are unable to even find a closed-form expression for the minimizer, and resort to bounds instead). Again, this makes the analysis more complicated.
We conclude this section by sketching how our bounds can be derived in case of second-order methods, and in the simplest possible setting, where we wish to obtain an lower bound for the class of convex functions with Lipschitz Hessians (and no assumptions on the Lipschitz parameter of the gradients), assuming the algorithm makes its first query at the origin. In that case, consider the function in this class of the form
[TABLE]
where is a parameter to be chosen later. Computing the derivatives and setting to zero, and arguing that the minimizer must have non-negative coordinates, we get that the optimum satisfies
[TABLE]
and
[TABLE]
It can be verified that this is satisfied by for all , and that this is the unique minimizer of as a function on . Moreover, assuming , the norm of this minimizer (and hence the initial distance to it from the algorithm’s first query point, by assumption) is at most as required. Plugging this into , we get that equals
[TABLE]
Now, using arguments very similar to those in first-order oracle complexity lower bounds (Nesterov, 2004), it is possible to construct a function for which the optimization error of the algorithm is lower bounded by . By the calculations above, this in turn equals
[TABLE]
Using the fact that for small , this equals . Choosing on the order of (as required earlier to satisfy the norm constraint on the minimizer), we get a lower bound of on the optimization error , or equivalently, a lower bound of on .
4 Proof of Thm. 1
We will assume without loss of generality that the algorithm initializes at (if that is not the case, one can simply replace the “hard” function below by , and the same proof holds verbatim). Thus, the theorem requires that our function has a minimizer satisfying .
Let be parameters to be chosen later. Define as
[TABLE]
which is easily verified to be convex and twice continuously differentiable, and let be orthogonal unit vectors in which will be specified later. Letting the number of iterations be fixed, we consider the function
[TABLE]
where is some sufficiently large number, and the dimension is at least .
The proof is constructed of several parts: First, we analyze properties of the global minimum of (Subsection 4.1). Then, we prove the oracle complexity lower bound in Subsection 4.2 (depending on ), and finally, in Subsection 4.3, we choose the parameters so that indeed has the various geometric properties specified in the theorem.
4.1 Minimizer of
The goal of this subsection is to prove the following proposition, which characterizes key properties of the global minimum of :
Proposition 1**.**
Suppose that and . Then has a unique minimizer which satisfies the following:
For any , it holds that . 2. 2.
There exists some such that for all indices , it holds that
. 3. 3.
* .*
Since is strongly convex, its global minimizer is unique and well-defined. To prove the proposition, we will consider the simpler strongly-convex function
[TABLE]
where
[TABLE]
and prove that its minimizer satisfies the following:
For any , it holds that (Lemma 2). 2. 2.
There exists some such that for all , it holds that (Lemma 3). 3. 3.
(Lemma 4)
We then argue that the minimizer of satisfies for all (Lemma 5), and that (Lemma 6), from which Proposition 1 follows.
We begin with the following technical key result:
Lemma 1**.**
It holds that , and
[TABLE]
Moreover, .
Proof.
We begin by showing that for all , first for and then for . To do so, note that yet , and therefore is a sub-optimal point. Thus, we must have . The only negative term in the definition of is , so we must have . We now argue that for all : Otherwise, let be the vector which equals for all , and note that since we just showed . Based on this, it is easily verified that
[TABLE]
which means that is the (unique) minimum of , hence . By definition of , this implies for all , hence for all .
We now turn to prove that is monotonically decreasing in . Suppose on the contrary that this is not the case, and let be the smallest index for which , and let . Define the vector to be
[TABLE]
Note that this vector must be different than , as , hence yet by assumption. On the other hand, it is easily verified that and for all555This is trivially true for . For , we have and . For , we have , and moreover, , which is [math] (hence ) if and less than if . , and therefore . But since is the unique global minimizer and , we get a contradiction, so we must have monotonically decreasing for all .
We now turn to prove the recursive relation . By differentiating and setting to zero (and using the fact that is monotonically decreasing in ), we get that
[TABLE]
and
[TABLE]
By unrolling this recursive form, we get
[TABLE]
from which the equation
[TABLE]
follows, again using the monotonicity of in .
It remains to prove that . By summing both sides of Eq. (12) from to we have that:
[TABLE]
So by using Eq. (11) we get the desired equality. ∎
Lemma 2**.**
For any ,
[TABLE]
Proof.
By the displayed equation in Lemma 1, we clearly have for all , and therefore
[TABLE]
Using the facts that is also always non-negative, that , and by Lemma 1,
[TABLE]
which implies that , which implies in turn
[TABLE]
On the other hand, again by Lemma 1, we know that
[TABLE]
and hence
[TABLE]
Let be the smallest index such that (such an index must exist since ). Since by Eq. (15), it follows that
[TABLE]
According to Eq. (16) and the fact that , it follows that
[TABLE]
and hence
[TABLE]
Using this and Eq. (14), it follows that for all ,
[TABLE]
Since we assumed , we have , so the above can be lower bounded by the simpler expression . Since we also know that is non-negative, the result follows.
∎
Lemma 3**.**
There exists an index such that
[TABLE]
Proof.
By Lemma 1, it holds for any that
[TABLE]
In particular, since for all , it follows that , and therefore
[TABLE]
Let be any index such that666Such an index must exist: By assumption, , so by Lemma 1, , hence . . By Eq. (18), this implies that
[TABLE]
Using the inequality above together with Eq. (17) and the monotonicity of , we get that for all such that ,
[TABLE]
This chain of inequalities implies that
[TABLE]
Let denote the unique index that satisfies , as well as for all between and 777Since monotonically decrease in , such an index must exist: On the one hand, can be verified to be at least (by Lemma 2 and the assumption , hence ). On the other hand, if we let be the largest index satisfying , we have by Lemma 1 that , which implies that , which is less than by the assumption on being large enough. Therefore, is at most as well.. Using the displayed inequality above, we get that for any ,
[TABLE]
so we get as required ∎
Lemma 4**.**
**
Proof.
We need to upper bound the squared Euclidean norm of . Note that for any vector , we have . Thus, by Lemma 1, Eq. (15), and the assumption that , the squared norm is at most
[TABLE]
which is at most ∎
Lemma 5**.**
* satisfies for all , where .*
Proof.
First, we argue that , whic minimizes
[TABLE]
also minimizes
[TABLE]
To see this, note that and differ only in that is replaced by . By definition of , we have that and coincide for any , from which it is easily verified that and have the same values and gradients at any for which for all . By Lemma 1 and the assumption , the global minimizer of belongs to this set, and therefore . But is strongly convex, hence has a unique point (the global minimizer) at which the gradient of is zero, hence is indeed the global minimizer of .
Next, since the global minimizer is invariant to multiplying the function by a fixed positive factor, we get that is also the global minimizer of
[TABLE]
where in the last step we used the fact that . Recalling that
[TABLE]
and that are orthogonal, we can write as , where is any orthogonal matrix with the first columns being . Therefore, the minimizer of satisfies . ∎
Lemma 6**.**
**
Proof.
is a function which can be written in the form , so by the Representer theorem, its minimizer must lie in the span of . Moreover, since these vectors are orthogonal and of unit norm, we have , and thus
[TABLE]
∎
4.2 Oracle Complexity Lower Bound
In this subsection, we prove the following oracle complexity lower bound, depending on the free parameter :
Proposition 2**.**
Assume that . Under the conditions of Proposition 1, it is possible to choose the vectors in the function , such that the number of iterations required to have is at least
[TABLE]
To prove the theorem, we will need the following key lemma, which establishes that oracle information at certain points do not leak any information on some of the vectors.
Lemma 7**.**
For any orthogonal to , it holds that do not depend on .
Proof.
Since the regularization term doesn’t depend on we can define and prove the result on . Using the definition of and differentiating, we have that
[TABLE]
[TABLE]
[TABLE]
By the assumption , and the fact that , we have that for all . Therefore, it is easily verified that the expressions above indeed do not depend on . ∎
Let us now fix any number of iterations . Using the previous results, we can provide a way to pick for any deterministic algorithm, such that we can provide a lower bound for the number of second-order oracle calls.
- •
First, we compute (which is possible since the algorithm is deterministic and is chosen before any oracle calls are made).
- •
We pick to be some unit vector orthogonal to . Assuming will also be orthogonal to (which will be ensured by the construction which follows), we have by Lemma 7 that the information provided by the oracle to the algorithm does not depend on , and thus depends only on which was already fixed. Since the algorithm is deterministic, this fixes the next query point .
- •
For , we repeat the process above: We compute , and pick to be some unit vectors orthogonal to , as well as all previously constructed ’s (this is always possible since the dimension is sufficiently large). By Lemma 7, as long as all vectors thus constructed are orthogonal to , the information provided to the algorithm does not depend on , and only depends on which were already determined. Therefore, the next query point is fixed.
- •
At the end of the process, we pick to be some unit vectors orthogonal to all previously chosen ’s as well as (this is possible since the dimension is large enough).
Using the facts that are orthogonal (and thus act as an orthonormal basis to a subspace of ), that is orthogonal to , and that (where is as defined in Proposition 1), we have
[TABLE]
By Proposition 1, we can lower bound the above by
[TABLE]
Using the strong convexity of , we therefore get
[TABLE]
To make the right-hand side smaller than , must satisfy
[TABLE]
Which is equivalent to
[TABLE]
Assuming , then
[TABLE]
We now turn to argue that we can also lower bound by . Otherwise, suppose by contradiction that we can have for some . From Proposition 1 we know that
[TABLE]
so as before, we have that
[TABLE]
and thus
[TABLE]
To make the right-hand side smaller than , must satisfy
[TABLE]
or equivalently
[TABLE]
But since we assume , this is at least , contradicting our earlier assumption.
Overall, we showed that is lower bounded by both , as well as , hence proving Proposition 2.
4.3 Setting the Parameters
In the following lemma, we establish the strong convexity and smoothness parameters of (depending on the parameter which is still free at this point).
Lemma 8**.**
* is -strongly convex and twice-differentiable, with -Lipschitz Hessians and -Lipschitz gradients.*
Proof.
Since is a sum of convex, twice-differentiable functions and the -strongly convex function , it is clearly -strongly convex and twice-differentiable. Thus, it only remains to calculate the Lipschitz parameter of the gradients and Hessians.
To simplify the proof, we note that Lipschitz smoothness is a property invariant to the coordinate system used, so we can assume without loss of generality that correspond to the standard basis , and consider the Lipschitz properties of the function
[TABLE]
By definition of , it is easily verified that
[TABLE]
which is a -Lipschitz function bounded in . This implies that is -Lipschitz. Letting , we can write as
[TABLE]
Differentiating twice, we get
[TABLE]
Since this is a sum of positive-semidefinite matrices with non-negative coefficients (as we showed that for all ), it follows that its spectral norm is at most
[TABLE]
and the first term equals
[TABLE]
Overall, we showed that , so the gradients of are -Lipschitz.
It remains to show that is -Lipschitz. Using the formula for , and recalling that is -Lipschitz, and by definition, we have that for any ,
[TABLE]
Using the same calculations as earlier, we have , and therefore we showed overall that
[TABLE]
hence is -Lipschitz. ∎
We now collect the ingredients necessary to fix and hence prove our theorem. Combining the previous lemma, Proposition 1 and Proposition 2, and recalling that we want to have -Lipschitz gradients and -Lipschitz Hessians, with an optimizer satisfying , we have an oracle complexity lower bound of the form
[TABLE]
assuming the following conditions:
[TABLE]
Picking , using the fact that (as any -strongly convex function must have gradients with Lipschitz parameter at least ), and rewriting the last two conditions, this is equivalent to
[TABLE]
Since the first condition needs to hold anyway, we can allow ourself to make the second condition stronger, by substituting in lieu of in the second condition. Doing this, simplifying, and merging the last two conditions, the set of condition above is implied by requiring
[TABLE]
Clearly, to make the lower bound in Eq. (19) as large as possible, we should pick the largest possible , namely , and to ensure that the other conditions hold, require that
[TABLE]
Simplifying a bit, these two conditions are implied by requiring
[TABLE]
Finally, let us plug our choice of into the lower bound in Eq. (19). We thus get an oracle complexity lower bound of
[TABLE]
under the conditions of Eq. (20).
To simplify the bound a bit, we note that we can lower bound by (possible by Eq. (20)), and lower bound by , by assuming that for some small enough (in other words, increasing the constant in the third condition in Eq. (20)). Finally, using the fact that , the result in the theorem follows.
5 Proof of Thm. 2
Similarly to the strongly convex case, we will assume without loss of generality that the algorithm initializes at , since otherwise one can simply replace the “hard” function below by , and the same proof holds verbatim. Thus, the theorem requires that our function has a minimizer satisfying .
Define as
[TABLE]
where . can be easily verified to be twice continuously differentiable. Assume that , and let be orthogonal unit vectors in which will be specified later. Given , and letting be a parameter to be specified later, define the function as
[TABLE]
This function is easily shown to be convex and twice-differentiable, with -Lipschitz gradients and -Lipschitz Hessians (the proof is identical to the proof of Lemma 8). Our goal will be to show a lower bound on the optimization error using this type of function.
5.1 Minimizer of
In this subsection, we analyze the properties of a minimizer of . To that end, we introduce the following function in :
[TABLE]
It is easily verified that the minimal values of and are the same, and moreover, if is a minimizer of , then is a minimizer of , and with the same Euclidean norm as .
We begin with the following technical lemma:
Lemma 9**.**
* has a unique minimizer , which satisfies*
[TABLE]
for all , where is non-negative and independent of t. Moreover,
[TABLE]
Proof.
Taking the derivative and setting to zero, we get that the
[TABLE]
as well as
[TABLE]
for all . By definition of , it is easily verified that is a strictly monotonic (hence invertible) function, so the above implies for all , as well as . From this, it follows by straightforward induction that , from which the first displayed equation in the lemma follows. This also implies , and since is strictly monotonic, we have that is uniquely defined, and since the other coordinates of are also uniquely defined given , we get that is unique. Finally, (and hence for all ) is necessarily non-negative, since otherwise is negative, which would imply , even though , violating the fact that minimizes . ∎
The main technical result in this subsection is the following proposition, which characterizes and under various parameter regimes. By the discussion above and definition of , we have
[TABLE]
which will be used in the remainder of the proof of our theorem.
Proposition 3**.**
The function and its minimizer has the following properties, depending on the values of :
[TABLE]
Proof.
To prove the proposition, we will consider three regimes, depending on : Namely, , and . We will show that each regime corresponds to one of the three regimes specified in the proposition, and prove the relevant bounds.
Case 1: . In that case, as well as for all in the definition of all lie in the interval where is a cubic function. Using Lemma 9,
[TABLE]
hence
[TABLE]
and
[TABLE]
Therefore, our condition is exactly equivalent to , namely the first regime discussed in the proposition. We now establish the relevant bounds:
[TABLE]
and
[TABLE]
where in the calculation above we used fact .
Case 2: . In this case, by Lemma 9, but . Therefore, in the definition , lies in the quadratic region of , whereas and for all lies in the cubic region of . As a result,
[TABLE]
Plugging in and , we get
[TABLE]
and therefore (using the fact , see Lemma 9),
[TABLE]
This, plus the assumption , is equivalent to , hence showing that we are indeed in the second regime as specified in our proposition. Turning to calculate the relevant bounds, we have
[TABLE]
Moreover,
[TABLE]
which by definition of above and the inequality for all , is at most .
Case 3: . In this case, by Lemma 9, we have , which implies that in the definition of , these terms all lie in the quadratic region of . Therefore,
[TABLE]
and thus
[TABLE]
or equivalently
[TABLE]
Note that this, plus our assumption , is equivalent to , which shows that we are indeed in the third regime as specified in our proposition. Turning to calculate and , we have
[TABLE]
and
[TABLE]
∎
5.2 Oracle Complexity Lower Bound
Given the expressions on the optimal value of , derived in the previous subsection, we turn to explain how the oracle complexity lower bound is derived. The argument is very similar to the strongly convex case (proof of Thm. 1, subsection 4.2): Specifically, consider the function , given by
[TABLE]
Given an algorithm, we choose to be orthogonal unit vectors, so that each is orthogonal to the first points computed by the algorithm (this is possible, since the gradients and Hessians of at each reveals no information on future ’s – see Lemma 7). Also, we let equal .
With this choice, it is easily verified that
[TABLE]
which is clearly no better than , where is defined with the same . Therefore, we can lower bound the optimization error by . Moreover, by Eq. (21), this equals
[TABLE]
Using proposition 3, we can now plug in these minimal values, depending on the various parameter regimes, and get an oracle complexity lower bound. Computing these bounds and parameter regimes (while picking the free parameter appropriately) is performed in the next subsection.
5.3 Setting the Parameter
To simplify notation, we let and be shorthand for and respectively, with minimizers and . We will consider three regimes, depending on the relationships between .
5.3.1 Case 1:
In this setting, we choose
[TABLE]
Using this and the assumption on the parameters, we get that , and therefore, we are in the first regime for both and as specified in proposition 3. Plugging in the bound on in that regime, and using the fact that by the assumption above, we have
[TABLE]
as required.
Using the results from proposition 3 for the first regime we can compute the optimization error bound
[TABLE]
Where in the first inequality we used the fact that for all and for the last inequality we assumed that . In the case that , the final result still holds. Hence, the suboptimality is at least .
5.3.2 Case 2:
In this setting, we choose
[TABLE]
Using this and the assumption on the parameters, we get that , and therefore, we are in the second regime for both and as specified in proposition 3. Plugging in the bound on in that regime, and using the fact that by the assumption above, we have
[TABLE]
as required.
Turning to compute the optimization error bound, and letting denote the quantity in proposition 3 for and respectively, we have
[TABLE]
To continue, we use the following auxiliary lemma:
Lemma 10**.**
**
Proof.
First we will prove that .
Since and using for we have that:
[TABLE]
So
[TABLE]
To complete the proof, it remains to show that . We have
[TABLE]
Define . Hence, we need to prove:
[TABLE]
Which is true since . ∎
With this lemma, we can lower bound the optimization error in Eq. (23) by
[TABLE]
To continue, we note that by definition of and the fact that , we have
[TABLE]
Therefore,
[TABLE]
Using this inequality, and the fact for , we can lower bound Eq. (24) by
[TABLE]
Hence, the suboptimality is at least .
5.3.3 Case 3:
In this setting, we choose
[TABLE]
Using this and the assumption on the parameters, we get that , and therefore, we are in the third regime for both and as specified in proposition 3. Plugging in the bound on in that regime, and using the fact that by the assumption above, we have
[TABLE]
Now, by the assumptions that and by using the fact that for all , the optimization error bound is
[TABLE]
In the last inequality we assumed that . For it can be easily verified that the inequality holds. Hence, using the suboptimality is at least .
5.4 Wrapping Up
Combining the three cases from the previous subsection, we see that we get the following lower bound
[TABLE]
Thus, we get that
[TABLE]
Equating these bounds to , and solving for , the theorem follows.
6 Proof of Thm. 3
The proof of Thm. 3 will follow the same outline of the proof of Thm. 2. We are again going to assume without loss of generality that , and we will thus require that (see discussion in the proof of Thm. 2). We define as
[TABLE]
and
[TABLE]
By the following lemma, is -times differentiable, with -Lipschitz order derivative tensor.
Lemma 11**.**
* is -times differentiable, with -Lipschitz order derivative tensor.*
Proof.
Similarly to Lemma 8, we can assume without loss of generality, that the vectors correspond to the standard basis vectors , so we can examine the Lipschitz property of
[TABLE]
Let
[TABLE]
By Differentiating times, we have that
[TABLE]
Where
[TABLE]
Since
[TABLE]
Note that for a -th order symmetric tensor , the operator norm equals (see e.g. (Mu et al., 2015)):
[TABLE]
So,
[TABLE]
Where in the first inequality we used that .
Plugging that into Eq. (25) we have that
[TABLE]
as required. ∎
6.1 Minimizer of
In order to derive the complexity bound, we will first analyze , which is a simplified version of , as defined in Subsection 5.1. It is easily verified that , and moreover, if is a minimizer of , then is a minimizer of , and with the same Euclidean norm as .
Using an identical proof to Lemma 9 we can have that has a unique minimizer , which satisfies
[TABLE]
for some and all and
[TABLE]
hence,
[TABLE]
By plugging the minimizer, we have that
[TABLE]
and,
[TABLE]
Where we used as in Proposition 3.
6.2 Oracle Complexity Lower Bound
The derivation of the lower complexity bound will be exactly the same as in Subsection 5.2.
In Subsection 5.2 we showed that we can lower bound the optimization error by . Using the fact that
[TABLE]
this equals
[TABLE]
Letting and to be the minimal values of and respectively, and by using equation Eq. (6.1) then
[TABLE]
The last inequality holds for , or . It can be verified that for the other cases, the inequality above holds.
Since we want to be as large as possible, we will set to be as large as possible, under the constraint that . By Eq. (6.1) we can choose
[TABLE]
[TABLE]
Thus, according to the discussion in Subsection 6.2, the final bound is
[TABLE]
and the number of iterations required for having , must satisfy
[TABLE]
Where .
Acknowledgments
We thank Yurii Nesterov for several helpful comments on a preliminary version of this paper, as well as Naman Agarwal, Elad Hazan and Zeyuan Allen-Zhu for informing us about the A-NPE algorithm of Monteiro and Svaiter (2013).
Appendix A An Improved Second-Order Oracle Complexity Bound for Strongly
Convex Functions
In this section, we show how the A-NPE algorithm of Monteiro and Svaiter [2013], which is a second-order method analyzed for smooth convex functions, can be used to yield near-optimal performance if the function is also strongly convex. Rather than directly adapting their analysis, which is non-trivial, we use a simple restarting scheme, which allows one to convert an algorithm for the convex setting, to an algorithm in the strongly convex setting888We note that the reverse direction, of adapting strongly convex optimization algorithms to the convex case, is more common in the literature, and can be achieved using regularization or more sophisticated approaches [Allen-Zhu and Hazan, 2016]..
Our algorithm is described as follows: In the first phase, we apply a generic restarting scheme (based on [Arjevani and Shamir, 2016a, Subsction 4.2]), where we repeatedly run A-NPE for a bounded number of steps, followed by restarting the algorithm, running it from the last iterate obtained. By strong convexity, we show that each such epoch reduces the suboptimality by a constant factor. Once we reach a point sufficiently close to the global optimum, we switch to the second phase, where we use the cubic-regularized Newton method to get a quadratic convergence rate.
To formalize this, let us first analyze the convergence rate of the first phase. We assume that we use the algorithm described in Monteiro and Svaiter [2013, Subsection 7.4]999Specifically, since in our framework we do not limit computational resources, we assume that the minimization problem in Eq. (6.1) of Monteiro and Svaiter [2013] can be solved exactly.. By [Monteiro and Svaiter, 2013, Theorem 6.4 and Theorem 3.10], we have that the ’th iterate satisfies
[TABLE]
where is the Lipschitz constant of , is the initialization point, is the unique minimizer (due to strong convexity) of , bounds from above, and is some universal constant. Since is also assumed to be -strongly convex, we have
[TABLE]
hence
[TABLE]
Thus, running the algorithm for
[TABLE]
iterations, we see that . Now, since the distance from to is also smaller than , we may initialize the algorithm at the last iterate returned by the previous run and run it for iterations to reduce in, yet again, a factor of 2. Applying the algorithm for iterations (and restarting the algorithmic parameters after every iterations) yields
[TABLE]
Equivalently, to obtain an -optimal solution, we need at most
[TABLE]
oracle calls (note that this restarting scheme can be applied also on uniform convex functions of any order (defined in, e.g., (Vladimirov et al. [1978])).
Next, after performing a number of iterations sufficiently large to obtain high accuracy solutions, we proceed to the second phase of the algorithm where cubic-regularized Newton steps are applied (see Nesterov [2008]). According to that analysis, after reducing the optimization error to below , the number of cubic-regularized Newton steps required to achieve an -suboptimal solution is
[TABLE]
Thus, using the -Lipschitzness of the gradient to bound from above by , we get that the overall number of iterations is at most
[TABLE]
The reference list from the paper itself. Each links out to its DOI / PubMed record.
- 1Agarwal and Hazan [2017] Naman Agarwal and Elad Hazan. Lower bounds for higher-order optimization. Working draft, 2017.
- 2Allen-Zhu and Hazan [2016] Zeyuan Allen-Zhu and Elad Hazan. Optimal black-box reductions between optimization objectives. In Advances in Neural Information Processing Systems , pages 1614–1622, 2016.
- 3Arjevani and Shamir [2016 a] Yossi Arjevani and Ohad Shamir. On the iteration complexity of oblivious first-order optimization algorithms. In International Conference on Machine Learning , pages 908–916, 2016 a.
- 4Arjevani and Shamir [2016 b] Yossi Arjevani and Ohad Shamir. Oracle complexity of second-order methods for finite-sum problems. ar Xiv preprint ar Xiv:1611.04982 , 2016 b.
- 5Bach [2010] Francis Bach. Self-concordant analysis for logistic regression. Electronic Journal of Statistics , 4:384–414, 2010.
- 6Baes [2009] Michel Baes. Estimate sequence methods: extensions and approximations. Institute for Operations Research, ETH, Zürich, Switzerland , 2009.
- 7Boyd and Vandenberghe [2004] Stephen Boyd and Lieven Vandenberghe. Convex optimization . Cambridge university press, 2004.
- 8Cartis et al. [2010] Coralia Cartis, Nicholas IM Gould, and Philippe L Toint. On the complexity of steepest descent, newton’s and regularized newton’s methods for nonconvex unconstrained optimization problems. Siam journal on optimization , 20(6):2833–2852, 2010.
