Many machine learning setups lead to the minimization a convex function of the form
where is a convex, compact set. When the functions are also convex, then the overall optimization problem is convex, and can in principle be solved using any off-the-shelf convex minimization procedure. In the machine learning literature, two primary techniques have typically been used to address such convex optimization problems. The first approach (called the batch approach) uses the ability to evaluate the function along with its gradients, Hessian etc. and applies first- and second-order methods to minimize the objective. The second approach (called the stochastic approach) interprets the average in Equation (1) as an expectation and uses stochastic gradient methods, randomly sampling a
and using its gradient and Hessian information as unbiased estimates for those of the function.111There is a body of literature that recognizes the ability of stochastic optimization to minimize testing error rather than training error in machine learning contexts (see e.g. Bottou and Bousquet, 2008), but we will focus on training error for this paper. Both these classes of algorithms have extensive literature on upper bounds for the complexities of specific methods. More fundamentally, there are also lower bound results on the minimum black-box complexity of the best-possible algorithm to solve convex minimization problems. In several broad problem classes, these lower bounds further coincide with the known upper bounds for specific methods, yielding a rather comprehensive general theory.
However, a recent line of work in the machine learning literature, recognizes that the specific problem (1) of interest has additional structure beyond a general convex minimization problem. For instance, the average in defining the function is over a fixed number
of functions, whereas typical complexity results on stochastic optimization allow for the expectation to be with respect to a continuous random variable. Recent works(Le Roux et al., 2012; Shalev-Shwartz and Zhang, 2013; Johnson and Zhang, 2013) make further assumptions that the functions involved in this sum are smooth, and the function is of course strongly convex by construction. Under these conditions, the algorithms studied in these works have the following properties: (i) the cost of each iteration is identical to stochastic optimization methods, and (ii) the convergence rate of the method is linear.222An optimization algorithm is linearly convergent if it reduces the sub-optimality by a constant factor at each iteration. The results are surprising since the existing lower bounds on stochastic optimization dictate that the error can decrease no faster than after iterations under such assumptions (Nemirovsky and Yudin, 1983), leaving an exponential gap compared to these new results. It is of course not a contradiction due to the finite sum structure of the problem (1) (following the terminology of Bertsekas (2012), we will call the setup of optimizing a finite sum incremental optimization hereafter).
Given this recent and highly interesting line of work, it is natural to ask just how much better can one do in this model of minimizing finite sums. Put another way, can we specialize the existing lower bounds for stochastic or batch optimization, to yield results for this new family of functions. The aim of such a result would be to understand the fundamental limits on any possible algorithm for this family of problems, and whether better algorithms are possible at all than the existing ones. Answering such questions is the goal of this work. To this end, we define the Incremental First-order Oracle (IFO) complexity model, where an algorithm picks an index and a point and the oracle returns . We consider the setting where each function is L-smooth (that is, it has L-Lipschitz continuous gradients). In this setting, we demonstrate that no method can achieve for all functions of the form (1), without performing calls to the IFO. As we will discuss following this main result, this lower bound is not too far from upper bounds for IFO methods such as SAG, SVRG and SAGA (Schmidt et al., 2013; Johnson and Zhang, 2013; Defazio et al., 2014) whose iteration complexity is . Some dual coordinate methods such as ASDCA and SPDC (Shalev-Shwartz and Zhang, 2014; Zhang and Xiao, 2014) get even closer to the lower bound, but are not IFO algorithms. Overall, there is no method with a precisely matching upper bound on its complexity, meaning that there is further room for improving either the upper or the lower bounds for this class of problems.
Following the statement of our main result, we will also discuss the implications of these lower bounds for the typical machine learning problems that have inspired this line of work. In particular, we will demonstrate that caution is needed in comparing the results between the standard first-order and IFO complexity models, and worst-case guarantees in the IFO model might not adequately capture the performance of the resulting methods in typical machine learning settings. We will also demonstrate regimes in which different IFO methods as well as standard first-order methods have their strengths and weaknesses.
Recent work of Arjevani (2014) also studies the problem of lower bounds on smooth and strongly convex optimization methods, although their development focuses on certain restricted subclasses of first-order methods (which includes SDCA but not the accelerated variants, for instance). Discussion on the technical distinctions in the two works is presented following our main result.
As a prerequisite for our result, we need the result on black-box first-order complexity of minimizing smooth and strongly convex functions. We provide a self-contained proof of this result in our paper in Appendix A which might be of independent interest. In fact, we establish a slight variation on the original result, in order to help prove our main result. Our main result will invoke this construction multiple times to design each of the components in the optimization problem (1).
The remainder of this paper is organized as follows. The next section formally describes the complexity model and the structural assumptions. We then state the main result, followed by a discussion of consequences for typical machine learning problems. The proofs are deferred to the subsequent section, with the more technical details in the appendix.
2 Setup and main result
Let us begin by formally describing the class of functions we will study in this paper. Recall that a function is called -smooth, if it has -Lipschitz continuous gradients, that is
where is the norm dual to . In this paper, we will only concern ourselves with scenarios where is a convex subset of a separable Hilbert space, with being the (self-dual) norm associated with the inner product. A function is called -strongly convex if
Given these definitions, we now define the family of functions being studied in this paper.
Let denote the class of all convex functions with the form (1), where each is -smooth and convex. Note that is -strongly convex and -smooth by construction, and hence where is the set of all -strongly convex and -smooth functions. However, as we will see in the sequel, it can often be a much smaller subset, particularly when the smoothness of the global function is much better than that of the local functions. We now define a natural oracle for optimization of functions with this structure, along with admissible algorithms.
[Incremental First-order Oracle (IFO)] For a function , the Incremental First-order Oracle (IFO) takes as input a point and index and returns the pair .
[IFO Algorithm] An optimization algorithm is an IFO algorithm if its specification does not depend on the cost function other than through calls to an IFO. For instance, a standard gradient algorithm would take the current iterate , and invoke the IFO with in turn with , in order to assemble the gradient of . A stochastic gradient algorithm would take the current iterate along with a randomly chosen index as inputs to IFO. Most interesting to our work, the recent SAG, SVRG and SAGA algorithms (Le Roux et al., 2012; Johnson and Zhang, 2013; Defazio et al., 2014) are IFO algorithms. On the other hand, dual coordinate ascent algorithms require access to the gradients of the conjugate of , and therefore are not IFO algorithms.
We now consider IFO algorithms that invoke the oracle times (at ) and output an estimate of the minimizer . Our goal is to bound the smallest number of queries needed for any method to ensure an error , uniformly for all . This complexity result will depend on the ratio which is analogous to the condition number that usually appears in complexity bounds for the optimization of smooth and strongly convex functions. Note that is strictly an upper bound on the condition number of , but also the best one in general given the structural information about .
In order to demonstrate our lower bound, we will make a specific choice of the problem domain . Let be the Hilbert space of real sequences with finite norm , and equipped with the standard inner product . We are now in a position to state our main result over the complexity of optimization for the function class .
Consider an IFO algorithm for problem (1) that performs calls to the oracle and output a solution . Then, for any , there exists a function such that and
In order to better interpret the result of the theorem, we state the following direct corollary which lower bounds the number of steps need to attain an accuracy of .
Consider an IFO algorithm for problem (1) that guarantees for any . Then there is a function on which the algorithm must perform at least IFO calls.
The first term in the lower bound simply asserts that any optimization method needs to make at least one query per , in order to even see each component of which is clearly necessary. The second term, which is more important since it depends on the desired accuracy , asserts that the problem becomes harder as the number of elements in the sum increases or as the problem conditioning worsens. Again, both these behaviors are qualitatively expected. Indeed as , the finite sum approaches an integral, and the IFO becomes equivalent to a generic stochastic-first order oracle for , under the constraint that the stochastic gradients are also Lipschitz continuous. Due to complexity of stochastic strongly-convex optimization (with no dependence on ), we do not expect the linear convergence of Corollary 2 to be valid as . Also, we certainly expect the problem to get harder as the ratio degrades. Indeed if all the functions were identical, whence the IFO becomes equivalent to a standard first-order oracle, the optimization complexity similarly depends on .
Whenever presented with a lower bound, it is natural to ask how it compares with the upper bounds for existing methods. We now compare our lower bound to upper bounds for standard optimization schemes for as well as specialized ones for . We specialize to for this discussion.
Comparison with optimal gradient methods:
As mentioned before, , and hence standard methods for optimization of smooth and strongly convex objectives apply. These methods need calls to the IFO for getting the gradient of , followed by an update. Using Nesterov’s optimal gradient method (Nesterov, 2004), one needs at most gradient evaluations to reach -optimal solution for , resulting in at most calls to the IFO. Comparing with our lower bound, there is a suboptimality of at most in this result. Since this is also the best possible complexity for minimizing a general , we conclude that there might indeed be room for improvement by exploiting the special structure here. Note that there is an important caveat in this comparison. For of the form (1), the smoothness constant for the overall function might be much smaller than , and the strong convexity term might be much higher than due to further contribution from the . In such scenarios. the optimal gradient methods will face a much smaller condition number in their complexity. This issue will be discussed in more detail in Section 3.
Comparison with the best known algorithms:
At least three algorithms recently developed for problem setting (1) offer complexity guarantees that are close to our lower bound. SAG, SVRG and SAGA (Le Roux et al., 2012; Johnson and Zhang, 2013; Defazio et al., 2014) all reach an optimization error after less than calls to the oracle. There are two differences from our lower bound. The first term of multiplies the term in the upper bounds, and the condition number dependence is as opposed to . This suggests that there is room to either improve the lower bound, or for algorithms with a better complexity. As observed earlier, the ASDCA and SPDC methods (Shalev-Shwartz and Zhang, 2014; Zhang and Xiao, 2014) reach a closer upper bound of , but these methods are not IFO algorithms.
Room for better lower bounds?
One natural question to ask is whether there is a natural way to improve the lower bound. As will become clear from the proof, a better lower bound is not possible for the hard problem instance which we construct. Indeed for the quadratic problem we construct, conjugate gradient descent can be used to solve the problem with a nearly matching upper bound. Hence there is no hope to improve the lower bounds without modifying the construction.
It might appear odd that the lower bound is stated in the infinite dimensional space. Indeed this is essential to rule out methods such as conjugate gradient descent solving the problem exactly in a finite number of iterations depending on the dimension only (without scaling with ). An alternative is to rule out such methods, which is precisely the approach Arjevani (2014) takes. On the other hand, the resulting lower bounds here are substantially stronger, since they apply to a broader class of methods. For instance, the restriction to stationary methods in Arjevani (2014) makes it difficult to allow any kind of adaptive sampling of the component functions as the optimization progresses, in addition to ruling out methods such as conjugate gradient.
3 Consequences for optimization in machine learning
With all the relevant results in place now, we will compare the efficiency of the different available methods in the context of solving typical machine learning problems. Recall the definitions of the constants and from before. In general, the full objective (1) has its own smoothness and strong convexity constants, which need not be the same as and . To that end, we define to be the smoothness constant of , and to the strong convexity of . It is immediately seen that provides an upper bound on , while provides a lower bound on .
In order to provide a meaningful comparison for incremental as well as batch methods, we follow Zhang and Xiao (2014) and compare the methods in terms of their batch complexity, that is, how many times one needs to perform calls to the IFO in order to ensure that the optimization error for the function is smaller than . When defining batch complexity, Zhang and Xiao (2014) observed that the incremental and batch methods have dependence on versus , but did not consider the different strong convexities that play a part for different algorithms. In this section, we also include the dual coordinate methods in our comparison since they are computationally interesting for the problem (1) even though they are not admissible in the IFO model. Doing so, the batch complexities can be summarized as in Table 1.
(Schmidt et al., 2013)
Based on the table, we see two main points of difference. First, the incremental methods rely on the smoothness of the individual components. That this is unavoidable is clear, since even the worst case lower bound of Theorem 2 depends on and not . As Zhang and Xiao (2014) observe, can in general be much smaller than . They attempt to address the problem to some extent by using non-uniform sampling, thereby making sure that the best of the and the worst of the have a similar smoothness constant under the reweighing. This does not fully bridge the gap between and as we will show next. However, more striking is the difference in the lower curvature across methods. To the best of our knowledge, all the existing analyses of coordinate ascent require a clear isolation of strong convexity, as in the function definition (1). These methods then rely on using as an estimate of the curvature of , and cannot adapt to any additional curvature when is much larger than . Our next example shows this can be a serious concern for many machine learning problems.
In order to simplify the following discussion we restrict ourselves to perhaps the most basic machine learning optimization problem, the regularized least-squares regression:
where is a data point and is a scalar target for prediction. It is then easy to see that so that with . To simplify the comparisons, assume that are drawn independently from a distribution defined on the sphere . This ensures that . Since each function has the same smoothness constant, the importance sampling techniques of Zhang and Xiao (2014) cannot help.
In order to succinctly compare algorithms, we use the notation to represent the batch complexity of without the term, which is common across all methods. Then we see that the upper bound for is
In order to follow the development of Table 1 for SAG and AGM, we need to evaluate the constants and . Note that in this special case, the constants and
are given by the upper and lower eigenvalues respectively of the matrix, where represents the empirical covariance matrix. In order to understand the scaling of this empirical covariance matrix, we shall invoke standard results on matrix concentration.
be the second moment matrix of thedistribution. Let and be its lowest and highest eigenvalues. Let us define the condition number of the penalized population objective
Equation (5.26) in (Vershynin, 2012) then implies that there are universal constants and
such that the following inequality holds with probability:
Let us weaken the above inequality slightly to use instead of in the bound, which is minor since we typically expect for statistical consistency. Then assuming we have enough samples to ensure that
we obtain the following bounds on the eigenvalues of the sample covariance matrix:
Using these estimates in the bounds of Table 1 gives
|ASDCA, SPDC (Eq. (3))|
|SAG (Eq. (5))|
|AGM (Eq. (6))|
Problems with :
This setting is quite interesting for machine learning, since it corresponds roughly to using when is a constant. In this regime, all the incremental methods seem to enjoy the best possible convergence rate of . When the population problem is relatively well conditioned, AGM obtains a similar complexity since . However, for poorly conditioned problems, the population condition number might scale with the dimension . We conclude that there is indeed a benefit from using the incremental methods over the batch methods in these settings, but it seems hard to distinguish between the complexities of accelerated methods like ASDCA and SPDC compared with SAG or SVRG.
Problems with large :
In this setting, the coordinate ascent methods seem to be at a disadvantage, because the average loss term provides additional strong convexity, which is exploited by both SAG and AGM, but not by ASDCA or SPDC methods. Indeed, we find that the complexity term can be made arbitrarily large as grows large. However, the contraction factors for both SAG and AGM do not grow with in this setting, leading to a large gap between the complexities. Between SAG and AGM, we conclude that SAG has a better bound when the population problem is poorly conditioned.
High-dimensional settings ():
In this setting, the global strong convexity can not really be larger than for the function (2), since the Hessian of the averaged loss has a non-trivial null space. It would appear then, that SAG is forced to use the same problem dependent constants as ASDCA/SPDC, while AGM gets no added benefit in strong convexity either. However, in such high-dimensional problems, one is often enforcing a low-dimensional structure in machine learning settings for generalization. In such structures, the global Hessian matrix can still satisfy restricted versions of strong convexity and smoothness conditions, which are often sufficient for batch optimization methods to succeed (Agarwal et al., 2012). In such situations, the comparison might once again resemble that of Table 2, and we leave such development to the reader.
In a nutshell, the superiority of incremental algorithms for the optimization of training error in machine learning is far more subtle than suggested by their worst case bounds. Among the incremental algorithms, SAG has favorable complexity results in all regimes despite the fact that both ASDCA and SPDC offer better worst case bounds. This is largely due to the adaptivity of SAG to the curvature of the problem. This might also explain in some part the empirical observation of Schmidt et al. (2013), who find that on some datasets SDCA (without acceleration) performed significantly poorly compared with other methods (see Figure 2 in their paper for details). Finally, we also observe that SAG does indeed improve upon the complexity of AGM after taking the different problem dependent constants into account, when the population problem is ill-conditioned and the data are appropriately bounded.
It is worth observing that all our comparisons are ignoring constants, and in some cases logarithmic factors, which of course play a role in the running time of the algorithms in practice. Note also that the worst case bounds for the incremental methods account for the worst possible choice of the functions in the sum. Better results might be possible when they are based on i.i.d. random data. Such results would be of great interest for machine learning.
4 Proof of main result
In this section, we provide the proof of Theorem 2. Our high-level strategy is the following. We will first construct the function such that each acts on only the projection of a point onto a smaller basis, with the bases being disjoint across the . Since the are separable, we then demonstrate that optimization of under an IFO is equivalent to the optimization of each under a standard first-order oracle. The functions will be constructed so that they in turn are smooth and strongly convex with appropriate constants. Hence, we can invoke the known result for the optimization of smooth and strongly convex objectives under a first-order oracle, obtaining a lower bound on the complexity of optimizing . We will now formalize this intuitive sketch.
4.1 Construction of a separable objective
We start with a simple definition.
denote the canonical basis vectors of, and let , , denote the orthonormal families .
For ease of presentation, we also extend the transpose notation for matrices over operators in in the natural manner (to avoid stating adjoint operators each time).
Given a finite or countable orthonormal family and , let
where is assumed to be zero when is greater than the size of the family.
Both and are square integrable and therefore belong to .
Using the above notation, we first establish some simple identities for the operators defined above.
Simple calculus yields the following identities:
Proof We start with the first claim. For any basis vector , it is easily checked that . By definition of , it further follows that . Linearity now yields for any , giving the first claim. For the second claim, we observe that unless , in which case . This implies the second claim. The third claim now follows from the first one, since . Similarly the final claim follows from the second claim.
We now define the family of separable functions that will be used to establish our lower bound.
All functions (7) belong to .
Proof We simply need to prove that the functions belong to . Using and Lemma 4.1, we can write
4.2 Decoupling the optimization across components
We would like to assert that the separable structure of allows us to reason about optimizing its components separately. Since the are not strongly convex by themselves, we first rewrite as a sum of separated strongly convex functions. Using Lemma 4.1,
We are almost done, but for one minor detail. Note that we want to obtain a lower bound where the IFO is invoked for a pair and responds with and . In order to claim that this suffices to optimize each separately, we need to argue that a first-order oracle for can be obtained from this information, knowing solely the structure of and not the functions . Since the strong convexity constant is assumed to be known to the algorithm, the additional in defining is also known to the algorithm. As a result, given an IFO for , we can construct a first-order oracle for any of the by simply returning and . Furthermore, an IFO invoked with the index reveals no information about for any other based on the separable nature of our problem. Hence, the IFO for offers no additional information beyond having a standard first-order oracle for each .
4.3 Proof of Theorem 2
Based on the discussion above, we can pick any and view our algorithm as a complicated setup whose sole purpose is to optimize function . Indeed, given the output of an algorithm using an IFO for the function , we can declare as our estimate for . Lemma 4.1 then yields
In order to establish the theorem, we now invoke the classical result on the black-box optimization of functions using a first-order oracle. The specific form of the result stated here is proved in Appendix A.
[Nemirovsky-Yudin] Consider a first order black box optimization algorithm for problem (9) that performs calls to the oracle and returns an estimate of the minimum. For any , there exists a function such that and
At a high-level, our oracle will make an independent choice of one of the functions that witness the lower bound in Theorem 4.3 for each . At a high-level, each function will be chosen to be a quadratic with an appropriate covariance structure such that queries to the function result in the estimation of at most coordinates of . By ensuring that the remaining entries still have a substantial norm, a lower bound for such functions is immediate. The precise details on the construction of these functions can be found in Appendix A.333The main difference with the original result of Nemirovsky and Yudin is the dependence on instead of . This is quite convenient in our setting, since it eliminates any possible interaction amongst the starting values of different coordinates for the different functions .
Suppose the IFO is invoked times on each index , with . We first establish the theorem for the case in which the algorithm cannot query each functions at least once. After receiving the response , we are still free to arbitrarily choose for any index that was never queried. No non-trivial accuracy is possible in this case.
Consider an IFO algorithm that satisfies the conditions of Theorem 2 with . Then there is a function such that .
Proof Let us execute the algorithm assuming that all the are equal to the function of Theorem 4.3 that attains the lower bound with . Since , there is at least one function for which . Since the IFO has not revealed anything about this function, we can construct function by redefining function to ensure that . Since is the only part of which is non-zero, we also get .
We can now assume without loss of generality that for each . Appealing to Theorem 4.3 for each in turn,
where the last inequality results from Jensen’s inequality applied to the convex function for . Finally, since the oracle has no way to discriminate amongst the values when , it will end up setting . With this setting, we now obtain the lower bound
for , along with for .
This completes the proof of the Theorem. In order to further establish Corollary 2, we need an additional technical lemma.
Proof The function is continuous and decreasing on because
The result follows because .
The results in this paper were motivated by recent results and optimism on exploiting the structure of minimizing finite sums, a problem which routinely arises in machine learning. Our main result provides a lower bound on the limits of gains that might be possible in this setting, allowing us to do a more careful comparison of this setting with regular first-order black box complexity results. As discussed in Section 3, the results seem mixed when the sum consists of functions based on random data drawn i.i.d. from a distribution. In this statistical setting, we find that the worst-case near-optimal methods like ASDCA can often be much worse than other methods like SAG and SVRG. However, IFO methods like SAG certainly improve upon optimal first-order methods agnostic of the finite sum structure, in ill-conditioned problems. In general, we observe that the problem dependent constants that appear in different methods can be quite different, even though this is not always recognized. We believe that accounting for these opportunities might open door to more interesting algorithms and analysis.
Of course, there is another and a possibly more important aspect of optimization in machine learning which we do not study in this paper. In typical machine learning problems, the goal of optimization is not just to minimize the objective —usually called the training error—to a numerical precision. In most problems, we eventually want to reason about test error, that is the accuracy of the predictions we make on unseen data. There are existing results (Bottou and Bousquet, 2008) which highlight the optimality of single-pass stochastic gradient optimization methods, when test error and not training error is taken into consideration. So far, we do not have any clear results comparing the efficacy of methods designed for the problem (1) in minimizing test error directly. We believe this is an important question for future research, and one that will perhaps be most crucial for the adoption of these methods in machine learning.
We believe that there are some important open questions for future works in this area, which we will conclude with:
Is there a fundamental gap between the best IFO methods and the dual coordinate methods in the achievable upper bounds? Or is there room to improve the upper bounds on the existing IFO methods. We certainly found it tricky to do the latter in our own attempts.
Is it possible to obtain better complexity upper bounds when the functions involved in the sum (1) are based on random data, rather than being arbitrary functions? Can the incremental methods exploit global rather than local smoothness properties in this setting?
What are the test error properties of incremental methods for machine learning problems? Specifically, can one do better than just adding up the optimization and generalization errors, and follow a more direct approach as the stochastic optimization literature?
We would like to thank Lin Xiao, Sham Kakade and Rong Ge for helpful discussions regarding the complexities of various methods. We also thank the anonymous reviewer who pointed out that the dual coordinate are not valid IFO algorithms.
Agarwal et al. (2012)
Alekh Agarwal, Sahand Negahban, and Martin J Wainwright.
Fast global convergence of gradient methods for high-dimensional statistical recovery.The Annals of Statistics, 40(5):2452–2482, 2012.
- Arjevani (2014) Y. Arjevani. On Lower and Upper Bounds in Smooth Strongly Convex Optimization - A Unified Approach via Linear Iterative Methods. ArXiv e-prints, 2014.
- Bertsekas (2012) Dimitri P. Bertsekas. Incremental gradient, subgradient, and proximal methods for convex optimization: A survey. In S. Sra, S. Nowozin, and S. J. Wright, editors, Optimization for Machine Learning, pages 85–119. MIT Press, 2012. Extended version: LIDS report LIDS-P2848, MIT, 2010.
- Bottou and Bousquet (2008) Léon Bottou and Olivier Bousquet. The tradeoffs of large scale learning. In J.C. Platt, D. Koller, Y. Singer, and S. Roweis, editors, Advances in Neural Information Processing Systems, volume 20, pages 161–168. NIPS Foundation (http://books.nips.cc), 2008. URL http://leon.bottou.org/papers/bottou-bousquet-2008.
- Defazio et al. (2014) Aaron Defazio, Francis Bach, and Simon Lacoste-Julien. Saga: A fast incremental gradient method with support for non-strongly convex composite objectives. In Advances in Neural Information Processing Systems, 2014.
- Johnson and Zhang (2013) Rie Johnson and Tong Zhang. In C.J.C. Burges, L. Bottou, M. Welling, Z. Ghahramani, and K.Q. Weinberger, editors, Advances in Neural Information Processing Systems 26, pages 315–323. 2013.
- Le Roux et al. (2012) Nicolas Le Roux, Mark Schmidt, and Francis Bach. A stochastic gradient method with an exponential convergence rate for finite training sets. In F. Pereira, C.J.C. Burges, L. Bottou, and K.Q. Weinberger, editors, Advances in Neural Information Processing Systems 25, pages 2663–2671. 2012.
- Nemirovsky and Yudin (1983) Arkadi Nemirovsky and David B. Yudin. Problem Complexity and Method Efficiency in Optimization. Interscience Series in Discrete Mathematics. Wiley, 1983.
- Nesterov (2004) Yurii Nesterov. Introductory Lectures on Convex Optimization. Kluwer Academic Publisher, 2004.
- Nesterov (2007) Yurii Nesterov. Gradient methods for minimizing composite objective function, 2007.
- Schmidt et al. (2013) Mark Schmidt, Nicolas Le Roux, and Francis Bach. Minimizing finite sums with the stochastic average gradient. arXiv preprint arXiv:1309.2388, 2013.
- Shalev-Shwartz and Zhang (2013) Shai Shalev-Shwartz and Tong Zhang. Stochastic dual coordinate ascent methods for regularized loss. The Journal of Machine Learning Research, 14(1):567–599, 2013.
- Shalev-Shwartz and Zhang (2014) Shai Shalev-Shwartz and Tong Zhang. Accelerated proximal stochastic dual coordinate ascent for regularized loss minimization. In Proceedings of the 31th International Conference on Machine Learning, ICML 2014, Beijing, China, 21-26 June 2014, pages 64–72, 2014.
Introduction to the non-asymptotic analysis of random matrices.In Yonina C. Eldar and Gitta Kutyniok, editors, Compressed Sensing, pages 210–268. Cambridge University Press, 2012.
- Zhang and Xiao (2014) Yuchen Zhang and Lin Xiao. Stochastic primal-dual coordinate method for regularized empirical risk minimization. Technical Report MSR-TR-2014-123, September 2014.
Appendix A Optimization of a strongly convex smooth functions
The most accessible derivation of this classic lower bound Nesterov (2004) relies on the simplifying assumption that the successive points lie in the span of the gradients previously returned by the oracle. This section provides a derivation of the lower bound that does not rely on this assumption and is critical for Theorem 2 where no such assumptions are made.
This section considers algorithms that produces an approximate solution of the optimization problem
using, as sole knowledge of function , an oracle that returns the value and the gradient on points successively determined by the algorithm. Note that this writing of is without loss of generality, since any -strongly convex function can be written in the form (9) where is convex.
We could equivalently consider an oracle that reveals and instead of and because these quantities can be computed from each other (since is known.)
At a high-level, our proof will have the following structure. We will first establish that any algorithm for solving the minimization problem (9) for all will be forced to play the point in the span of the previous iterates and gradients. This essentially shows that the restriction made by Nesterov is not too serious. The second part of the proof constructs a resisting oracle for such algorithms whose final query point falls within the span of the previous responses. Combining these ingredients, we obtain the desired lower bound.
a.1 Restriction of final solution to span
Consider an algorithm that calls the oracle on successive points . The first part of the proof describes how to pick the best possible on the basis of the oracle answers and the algorithm’s queries.
For any , let be the set of all functions that reach their minimum in a point such that .
Let be the set of the functions of whose values and gradients coincide with those of on points . Let be the set of their minima.
When the function is clear from the context, we will drop the superscript for brevity. Since all functions in are compatible with the values returned by the oracle, running our algorithm on any of them would perform the same calls to the oracle and obtain the same answers. Therefore, in order to offer the best guarantee on without further knowledge of the function , our algorithm must choose to be the center of the smallest ball containing .
Let . Let be the orthogonal projection of point on and let be its mirror image with respect to .
Stated differently, we know that any point can be decomposed into and such that . Then the above definition yields , which is the natural reflection of with respect to the subspace .
The set is symmetric with respect to .
Proof Consider an arbitrary point which minimizes a function . Since function also belongs to , its minimum also belongs to .
The center of the smallest ball enclosing belongs to .
We are now in a position to present the main ingredient of our proof that allows us to state a more general result than Nesterov. In particular, we demonstrate that the assumption made by Nesterov about the iterates lying in the span of previous gradients can be made almost without loss of generality. The key distinction is that we can only make it on the step , where the algorithm is constrained to produce a good answer, while Nesterov assumes it on all iterates, somewhat restricting the class of admissible algorithms.
For any and any algorithm that performs calls of the oracle and produces an approximate solution of problem (9), there is an algorithm that performs calls of the oracle and produces an approximate solution for all such that
Proof Consider an algorithm that first runs algorithm and then returns the center of the smallest ball enclosing as . Corollary A.1 ensures that belongs to the posited span. This choice of also ensures that . Equivalently, , where we use the fact that and because function coincides with on . Therefore,
This inequality implies (10) because .
Lemma A.1 means that we can restrict the analysis to algorithms that pick their final estimate in the subspace that results from the execution of the algorithm. In order to establish a lower bound for such an algorithm, it is sufficient to construct a function whose minimum is located sufficiently far away from this subspace. We construct this function by running the algorithm against a resisting oracle, which is quite standard in these lower bound proofs. Each call to the resisting oracle picks a new objective function among all the functions that agree with the values and gradients returned by all previous calls to the oracle. This constraint ensures that the optimization algorithm would have reached the same state if it had been run against function instead of the resisting oracle.
a.2 Construction of a resisting oracle
We start by defining the basic structure of the function which will be used by our oracle to construct hard problem instances. This structure is identical to that used by Nesterov.
[Nesterov] Fix and let denote the function
and reaches its minimum in with .
Proof The assertions and follow from direct calculation, as shown in Nesterov (2004, p.67).
We can arbitrarily choose the value of by appropriately selecting .
We also need some other properties of the function, which are also present in Nesterov’s analysis.
Let be the canonical basis of and let .
Proof Through a direct calculation, it is easy to verify that