Never Go Full Batch (in Stochastic Convex Optimization)
Year: 2021

Abstract:
We study the generalization performance of full-batch optimization algorithms for stochastic convex optimization: these are first-order methods that only access the exact gradient of the empirical risk (rather than gradients with respect to individual data points), that include a wide range of algorithms such as gradient descent, mirror descent, and their regularized and/or accelerated variants. We provide a new separation result showing that, while algorithms such as stochastic gradient descent can generalize and optimize the population risk to within ε after $ (1/ε2) iterations, full-batch methods either need at least Ω(1/ε4) iterations or exhibit a dimension-dependent sample complexity.

heading: 1 Introduction
text: Stochastic ConvexOptimization (SCO) is a fundamental problem that received considerable attention from the machine learning community in recent years [28, 15, 4, 11, 2]. In this problem, we assume a learner that is provided with a finite sample of convex functions drawn i.i.d. from an unknown distribution. The learner’s goal is to minimize the expected function. Owing to its simplicity, it serves as an almost ideal theoretical model for studying generalization properties of optimization algorithms ubiquitous in practice, particularly first-order methods which utilize only first derivatives of the loss rather than higher-order ones. One prominent approach for SCO—and learning more broadly—is to consider the empirical risk (the average objective over the sample) and apply a first-order optimization algorithm to minimize it. The problem of learning is then decoupled into controlling the optimization error over the empirical risk (training error) and bounding the difference between the empirical error and the expected error (generalization error). In convex optimization, the convergence of different first-order methods has been researched extensively for many years (e.g., [26, 25, 5]), and we currently have a very good understanding of this setting in terms of upper as well lower bounds on worst-case complexity. However, in SCO where the generalization error must also be taken into account, our understanding is still lacking. In fact, this is one of the few theoretical learning models where the optimization method affects not only the optimization error but also the generalization error (distinctively from models such as PAC learning and generalized linear models). In particular, it has been shown [28, 15] that some minima of the empirical risk may obtain large generalization error, while other minima have a vanishingly small
35th Conference on Neural Information Processing Systems (NeurIPS 2021).
generalization error. To put differently, learning in SCO is not only a question of minimizing the empirical risk, but also a question of how one minimizes it. However, the results of [28, 15] leave open the question of whether concrete optimization also have different generalization properties. Towards better understanding, Amir et al. [2] recently studied the generalization properties of fullbatch gradient descent (GD), where each step is taken with respect to the gradient of the empirical risk. For GD (and a regularized variant thereof), they gave a lower bound on the generalization error as a function of iteration number, which is strictly larger than the well-known optimal rate obtained by stochastic gradient descent (SGD), where each step is taken with respect to the gradient at a sampled example. Notably, the lower bound of [2] precisely matches the dimension-independent stability-based upper bound recently shown for full-batch GD by Bassily et al. [4]. The separation between full-batch GD and SGD is the first evidence that not only abstract Empirical RiskMinimizers may fail to generalize in SCO, but in fact also basic methods such as GD could be prone to such overfitting. A natural question is, then, whether overfitting is inherent to full-batch algorithms, that minimize the objective only through access to the exact empirical risk, or whether this suboptimality can be remedied by adding regularization, noise, smoothing, or any other mechanism for improving the generalization of GD. In this work we present and analyze a model of full-batch optimization algorithms for SCO. Namely, we focus on algorithms that access the empirical risk only via a first-order oracle that computes the exact (full-batch) gradient of the empirical loss, rather than directly accessing gradients with respect to individual samples. Our main result provides a negative answer to the question above by significantly generalizing and extending the result of Amir et al. [2]: we show that any optimization method that uses full-batch gradients needs at least Ω(1/ε4) iterations to minimize the expected loss to within ε error. This is in contrast with the empirical loss, which can be minimized with only $ (1/ε2) steps. Comparing SGD and GD in terms of the sample size =, we see that SGD converges to an optimal generalization error of $ (1/ √ =) after $ (=) iterations, whereas a full-batch method must perform Ω(=2) iterations to achieve the same $ (1/ √ =) test error. We emphasize that we account here for the oracle complexity, which coincides with the iteration complexity in the case of gradient methods. In terms of individual gradients calculations, while SGD uses at most $ (=) gradient calculations (one sample per iteration), a full-batch method will perform Ω(=3) calculations (= samples per iteration). The above result is applicable to a wide family of full-batch learning algorithms: regularized GD (with any data-independent regularization function), noisy GD, GDwith line-search or adaptive step sizes, GD with momentum, proximal methods, coordinate methods, and many more. Taken together with upper bound of Bassily et al. [4], we obtain a sharp rate of Θ(1/ε4) for the generalizationcomplexity of full-batch methods. Surprisingly, this rate is achieved by standard GD (with an unusual step-size choice of η = Θ(ε3)), and it cannot be improved by adding regularization of any sort, nor by adding noise or any other form of implicit/explicit bias.

heading: 1.1 Related work
text: This work extends and generalizes the results of Amir et al. [2] who proved generalization lower bounds for GD (and a specific instance of regularized GD). Our work shows that in fact any full-batch method will suffer from similar lower bounds. Our construction builds upon the one used in [2], which in turn builds upon previous constructions [4, 28]. However, our arguments and proofs here are more challenging, as we need to reason about a general family of algorithms, and not about a specific algorithm whose trajectory can be analyzed directly. Our developments also build on ideas from the literature on oracle complexity lower bounds in optimization [25, 26, 30, 8, 12, 9]. In particular, we first prove our result in the simplified setting of algorithms constrained to the span of observed gradients [25, 26] and subsequently lift it to general algorithms using a random high-dimensional embedding technique proposed byWoodworth and Srebro [30] and later refined in [8, 12]. However, while these works lower bound what we call the empirical risk, we lower bound the generalization error. This requires us to develop a somewhat different argument for how the span of the gradients evolve during the optimization: in prior work, the algorithm learns the component of the solution coordinate by coordinate, whereas in our work the true (generalizing) solution is present in the observed gradients from the first query, but spurious sampling artifacts drown it out.
Empirical studies (outside of the scope of SCO) support the claim that generalization capabilities degrade with the increase of the batch size. Specifically, Zhu et al. [33] indicates that SGD outperforms GD in terms of generalization. The works of Keskar et al. [22] and Hoffer et al. [20] exhibit a similar phenomenon in which small-batch SGD generalizes better than large-batch SGD with the same iteration budget. We provide the first theoretical evidence for this phenomenon for convex losses. Several theoretical studies explore the convergence of stochastic methods that use mini-batches [10, 23, 31]. Note that this setting differs from ours, as they assume access to minibatches sampled without replacement whereas full-batch means we reuse the same (full) batch with each gradient step. There has also been recent progress in improving the generalization capabilities of GD. Wu et al. [32] interprets mini-batch SGD as a noisy version of GD. They propose a modified algorithm with noise injected to the full-batch gradients. Geiping et al. [16] propose a GD-based training scheme that achieves CIFAR-10 generalization performance comparable to standard SGD training. Interestingly, both proposed algorithms require access to sample-points and are therefore not “fullbatch” by our definition: The scheme [32] requires sample-point data for computing the noise, while the GD variant [16] uses mini-batch statistics to compute a regularization term (as well as batch normalization). Our work shows that (in SCO) this is unavoidable: namely, no data-independent noise or full-batch regularization can be used to improve generalization at a reasonable computational budget. Several other works study the generalization performance of GD [29, 17, 21, 24]. The work of Soudry et al. [29], for example, examines GD on unregularized logistic regression problems. They show that, in the limit, GD converges to a well-generalizing solution by arguing about the bias of the algorithm. Interestingly, both our and their results require slow-training, beyond what is required for empirical error optimization. Another work that highlights the slow convergence of GD is that of Bassily et al. [4]. They were the first to address uniform stability of (non-smooth) GD and SGD, and provided tight bounds. Stability entails generalization, hence our results lead to stability lower bounds for any full-batch method. Consequently, we extend the lower bounds for GD in the work of Bassily et al. [4] to a wider class. It might be thought that the instability argument of Bassily et al. [4] can be used to obtain similar generalization lower bounds—however, we note that their techniques also prove instability of SGD (which does generalize). Hence, instability does not immediately imply, in this setting, lack of generalization. Finally, we note that under smoothness and strong convexity, it is well known that improved rates can be obtained. Specifically, using the stability bound of Bousquet and Elisseeff [6] one can show that we can achieve generalization error of $ (1/ √ =) after $ (=) iterations if the population risk is $ (1)-strongly convex. The arguments of Hardt et al. [19] imply generalization bound to instances where every sample risk is $ ( √ =) smooth. Our result implies that, even though these special families of functions enjoy appealing learning rates, in general it is impossible to obtain better rates by strong-convexifying or smoothing problem instances via first-order full-batch oracle queries.

heading: 2 Problem Setup and Main Results
text: We study the standard setting of stochastic convex optimization. In this setting, a learning problem is specified by a fixed domain W ⊆ ℝ3 in 3-dimensional Euclidean space, and a loss function 5 : W × Z → ℝ, which is both convex and !-Lipschitz with respect to its first argument (that is, for any I ∈ Z the function 5 (F; I) is !-Lipschitz and convex with respect to F). In particular, throughout the paper, our construction consists of 1-Lipschitz functions and we will focus on a fixed domain W defined to be the unit Euclidean ball in ℝ3 , namely W = {F : ‖F‖2 ≤ 1}. We also assume that there exists an unknown distribution over parameters I and the goal of the learner is to optimize the true risk (or true loss, or population risk) defined as follows:
(F) B E I∼ [ 5 (F; I)], (1)
We assume that a sample ( = {I1, . . . , I=} is drawn from the distribution , and the learner has to output F( ∈ W (the exact access the learner has to the sample, and how F( may depend on ( is discussed below). We require the solution to be ε-optimal in expectation for some parameter ε > 0, i.e.,
E (∼ = [ (F()] − min F★∈W (F★) ≤ ε.
As discussed, the standard setting assumes that the learner has direct access to the i.i.d. sample, as well as to the gradients of the loss function (i.e., a first-order oracle). In this work, though, we focus on a specific family full-batch methods. Hence, the optimization process is described as follows: First, an i.i.d. sample ( = (I1, . . . , I=) is drawn from . Then, the learner is provided with access only to the empirical risk via a full-batch first-order oracle which we define next.
Full-batch first-order oracle. Consider a fixed sample ( = (I1, . . . , I=) of size =, drawn i.i.d. from . The empirical risk over the sample ( is
( (F) = 1 = =∑ 8=1 5 (F; I8).
Then, a full-batch first-order oracle is a procedure that, given input F ∈W, outputs O(F) := (∇ ( (F); ( (F)). where ∇ ( (F) is an empirical risk sub-gradient of the form
∇ ( (F) = 1 = =∑ 8=1 ∇ 5 (F; I8), (2)
and each sub-gradient ∇ 5 (F, I8) is computed by the oracle as a function of F and I8 (that is, independently of I 9 for 9 ≠ 8). We emphasize that the sample is fixed throughout the optimization, so that the oracle computes the gradient of the same empirical risk function at every call, hence the name full-batch. Note that the subgradient with respect to a single data point, i.e., ∇ 5 (F; I8), is not accessible through this oracle, which only returns the average gradient over the sample (. Notice that our definition above is slightly narrower than a general sub-gradient oracle for the empirical risk due to the requirement that the sub-gradients ∇ 5 (F, I8) are chosen independently of I 9 for 9 ≠ 8 – since we provide here with a lower bound, this restriction strengthens our result. We make this restriction to avoid some degenerate constructions (that in fact can even be used to fail SGD if the gradient at I8 may depend on the whole sample), which are of no practical implications.
Full-batch first-order algorithm. A full-batch (first-order) method is naturally defined as any algorithm that has access to the optimization objective—namely the empirical risk (—only via the full-batch first order oracle. In particular, if FC is the C’th query of the algorithm to the full-batch oracle then FC has to be of the form FC = &C (O(F0), . . . ,O(FC−1)), (3) where &C : (ℝ3+1)C → W is a fixed (possibly randomized) mapping. At the end of the process the algorithm outputs F( . We study the algorithm’s oracle complexity, which is the number of iterations ) the algorithm performs before halting. Therefore, we assume without loss of generality that F( = F) , i.e., the algorithm’s output is its )’th query.

heading: 2.1 Main result
text: In this sectionwe establish ourmain result, which provides a generalization lower-bound for full-batch first order algorithms. The complete proof is provided in the full version of the paper [1]. Theorem 2.1. Let ε > 0 and =, ) ∈ ℕ; there exists 3 = poly(2=, ), 1/ε) such that the following holds. For any full-batch first-order algorithm with oracle complexity at most ) , there exists a 1-Lipschitz convex function 5 (F; I) inW, the unit-ball inℝ3 , and a distribution overZ such that, for some universal constant 2 > 0:
E (∼ = [ (F()] ≥ min F★∈W
(F★) + ε + Ω ( min { 1 − 2ε2 √ ), 0 }) . (4)
An immediate consequence of Theorem 2.1 is that in order to obtain less than ε true risk we need at least ) = Ω(1/ε4) iterations. For simplicity, we state and prove the lower bound in Theorem 2.1 for the class of first-order fullbatch algorithms defined above. However, our constructions readily generalize to local full-batch oracles that provide a complete description of ( in an arbitrarily small neighborhood of the query point [25, 18]. Such oracles subsume second-order oracles, and consequently our generalization lower bounds hold also for second-order full-batch algorithms.

heading: 2.2 Discussion
text: Theorem 2.1 suggests that full-batch first-order algorithms are inferior to other types of first-order algorithms that operate with access to individual examples, such as SGD. Importantly, this separation is achieved not in terms of the optimization performance but in terms of the generalization performance. In light of this result, we next discuss and revisit the role of the optimization algorithm in the context of SCO. In particular, we wish to discuss the implications to what are perhaps the two most prominent full-batch optimization methods, GD and regularzied-GD, and in turn compare them.
Gradient descent. Perhaps the simplest example of a full-batch method is (projected) GD: GD is an iterative algorithm that at each iteration performs an update step
FC = ΠW [FC−1 − η∇ ( (FC )],
where W is a convex set on which we project the iterated step. The output of GD is normally taken to be F( = 1) ∑ FC (or a randomly chosen FC ). Notice, that each step requires one call to a full batch oracle, and a single projection operation. The convergence analysis of GD to the optimal solution of the empirical risk has been widely studied. Specifically, if = is the sample-size, it is known that with η = $ (1/ √ =) and ) = $ (=), GD converges to a minimizer of ( that is $ (1/ √ =)-sub optimal. For the exact variant of GD depicted above, the generalization performance was analyzed in the work of Amir et al. [2] that showed that with ) = $ (=) steps, GD will suffer Ω(1/ 4 √ =) generalization error. Theorem 2.1 extends the above result to any variant of GD (dynamic learning-rate, noisy GD, normalized GD, etc.).
Regularized gradient descent. We would also like to discuss the implication of Theorem 2.1 with respect to regularized variants of GD that operate on the regularized empirical risk
̂ (F) = λA (F) + ( (F).
The main motivation of introducing the regularization term A is to avoid overfitting, and a popular choice for A is the Euclidean norm A (F) = ‖F‖22. This choice leads to the following update rule for GD: FC+1 = ΠW [(1 − ηC ) · (2λFC ) − ηC∇ ( (FC )] , Again, this update can be implemented using a single first-order full-batch oracle call that computes the quantity∇ ( (FC ). More generally, for any data-independent A , GDon ̂ is a full-batch algorithm1. When A is the Euclidean norm, the minimizer of ̂ is known to enjoy (with choice λ = $ (1/ √ =)), an optimal generalization error of $ (1/ √ =) [6, 28]. This demonstrates the power of regularization and how it can provably induce generalization. Nevertheless, Theorem 2.1 still applies to any optimization method over ̂. Since optimization of ̂ (the regularized empirical risk) to $ (1/ √ =)- precision can be done via a full-batch method, and with less than $ (=) calls, we observe that there are methods that minimize the regularized-empirical risk but, due to Theorem 2.1 do not reach the optimal generalization error.
The role of regularization. Finally, in light of Theorem 2.1 let us compare the different variants of GD and regularized GD that do generalize well, in order to sharpen our understanding of the role of regularization in generalization. The conclusion of Theorem 2.1 is that any full-batch method that generalizes well performs at least $ (=2) steps. For regularized GD, with `2 regularization, $ (=2) are indeed sufficient. In particular, with $ (=2) iterations we can find a solution that has $ (1/=) empirical error. Any such solution would enjoy a generalization error of $ (1/ √ =) [28]. For GD, Bassily et al. [4] showed that $ (=2) iterations would also suffice to achieve $ (1/ √ =) error. This is achieved by tuning the learning rate to η = $ (1/=3/2). Notice that this improvement does not require any type of added regularization. To summarize, both GD and regularized GD with optimal parameters require Θ(=2) iterations to attain the optimal$ (1/ √ =) generalization error. Overall then, explicitly adding regularization is not necessary nor does it improve the convergence rate. One might be tempted to believe that tuning the learning rate in GD induces implicitly some sort of regularization. For example, one might
1Note that we are not concerned with the computational cost of computing ∇A (FC ) since it does not factor into oracle complexity.
imagine that GD can be biased towards minimal norm solution, which might explain redundancy of regularizing by this norm. However, this turns out also to be false: Dauber et al. [11] showed how GD (with any reasonable choice of learning rate) can diverge from the minimal norm solution. In fact, for any regularization term A, one can find examples where GD does not converge to the regularized solution. Thus, even though GD and regularized-GD are comparable algorithms in terms of generalization and oracle complexity, they are distinct in terms of the solutions they select.

heading: 3 Technical Overview
text: In this section we give an overview of our construction and approach towards proving Theorem 2.1. For the sake of exposition, we will describe here a slightly simpler construction which proves the main result only for algorithms that remain in the span of the gradients. In more detail, let us examine the family of iterative algorithms of the form
FC ∈ span{∇ ( (F0),∇ ( (F1), . . . ,∇ ( (FC−1)} ∩W, (5) where W is the unit ball and ∇ ( (FC ) is full-batch oracle response to query FC as defined in (2) above. Well-studied algorithms such as GD and GD with standard `2 norm regularization fall into this category of algorithms. To extend the lower bound to algorithms not restricted to the gradient span we refine the simpler construction and apply well-established techniques of random embedding in high-dimensional space. We discuss thesemodifications briefly in the end of this section and provide the full details in Section 4 and the full version of the paper [1].

heading: 3.1 A simpler construction
text: Let us fix =, 3 ≥ 1 and parameters I = (α, ε, γ) ∈ {0, 1}3 × ℝ × ℝ2 = Z, such that α ∈ {0, 1}3 , ε > 0 and γ1, γ2 > 0. Define the hard instance 5(6) : ℝ3+2 ×Z→ ℝ as follows:
5(6) (F; (α, ε, γ)) = 6γ(F;α) + γ1Eα · F + εF · 43+2 + A (F), (6) where 6γ, Eα and A are
• 6γ(F;α) B √∑ 8∈[3 ] α(8)ℎ2γ(F(8)) with ℎγ(0) B { 0 0 ≥ −γ2; 0 + γ2 0 < −γ2,
• A (F) B max{0,max8∈[3+1]{F(8)}}, • Eα (8) B  − 12= if α(8) = 0; +1 if α(8) = 1; 0 if 8 ∈ {3 + 1, 3 + 2},
and 43+2 is the (3 + 2)’th standard basis vector. The distribution we will consider is uniform over α. That is, we draw α ∈ {0, 1}3 uniformly at random and pick the function 5(6) (F; (α, ε, γ)). The parameters γ1 and γ2 of the construction should be thought of as arbitrarily small. In particular, the term γ1Eα · F in Eq. (6) should be thought of as negligible, and the first term, 6γ, is roughly
6γ(F;α) ≈ √∑ 8∈3 α(8) (max{−F(8), 0})2.
Another useful property of the construction is the population risk (F) = EI∼ 5(6) (F; I) is minimized at F★ ≈ −43+2, with expected loss (F★) ≈ −ε. However, as we will see, the choice of the perturbation vector Eα and the term A (F) hinder the learner from observing this coordinate and; the first Ω(ε−4) queries are constrained to a linear subspace where all the points have a high generalization error due to the expectation of the first term 6γ.

heading: 3.2 Analysis
text: We next state the main lemmas we use, with proofs deferred to the full version of the paper [1]. Given a sample (, let us denote Ē = 1
=
∑ α∈( Eα, and
span1{D1, D2, . . .} B span{D1, D2, . . .} ∩W.
Additionally, given a fixed sample we write
I(() = {8 : α(8) = 0 ∀α ∈ (} ∪ {3 + 1} for the set of coordinates 8 ∈ [3] such that α(8) = 0 for every α in the sample (, plus the coordinate 3 + 1. Lemma 3.1. Let γ1 ≤ 12) , γ2 = 2γ1 ε , and suppose that the sample ( satisfies |I(() | > ) . Then there exists a first-order full-batch oracle such that for any algorithm that adheres to
FC ∈ span1 { ∇ ( (F0),∇ ( (F1), . . . ,∇ ( (FC−1) } , (7)
with respect to 5 (F; (α, ε, γ)) defined in Eq. (6), we have
FC ∈ span1 8∈IC (()
{ γ1Ē + ε43+2 + 48 } for all C ∈ [)],
where IC (() is the set of the C + 1 largest coordinates in I(().
We next observe that in any span of the form {γ1Ē + ε43+2 + 48}8∈I) (() such that |I) (() | ≤ ) , we cannot find a solution with better risk than 0. On the other hand, note that for F̄ = −43+2, we have that 5(6) (F̄; (α, ε, γ)) = −ε. In other words, our lower bound stems from the following result: Lemma 3.2. For sufficiently small γ1 ≤ 2=εγ2, γ2 ≤ ε/ √ 4) , and any vector ‖Ē‖ ≤ √ 3, any output
F( ∈ span1 8∈I) (() {γ1Ē + ε43+2 + 48},
satisfies
1 2 √∑ 8∈[3 ] ℎ2γ(F( (8)) + εF( (43+2) ≥ min { 1 − 2ε2 √ ), 0 } − 1 2 ε. (8)
Lower bound proof sketch for span-restricted algorithms of the form (5). First, observe that the probability of an arbitrary index 8 to satisfy α(8) = 0 for all α ∈ ( is (1/2)=. Therefore, |I(() | −1, the number of indexes that hold this from the possible 3, is distributed as a binomial with 3 experiments and success probability ? = 2−=. Using elementary probability arguments one can show that for sufficiently large 3 we have |I(() | > ) with high probability; see Claim B.2 in the appendix. This implies that the conditions of Lemmas 3.1 and 3.2 hold w.h.p. To conclude, we relate the LHS of Eq. (8) to the expected risk
(F) = E α∼ [ 5(6) (F; (α, ε, γ))] = E α∼ [6γ(F;α)] + γ1 · E α∼ [Eα] · F + εF · 43+2 + A (F).
As 6γ(F;α) is convex w.r.t. α (since α(8) = α2 (8)) we can apply Jensen’s inequality with Eα∼ [α(8)] = 12 to obtain:
E α∼ [6γ(F(;α)] ≥ 1 2 √∑ 8∈[3 ] ℎ2γ(F( (8)).
Applying theCauchy-Schwarz inequality to the second termwhile also using the facts that ‖Eα‖ ≤ √ 3 and that F( is in the unit ball, we get:
γ1 E α∼ [Eα] · F ≥ −γ1 E α∼ [‖Eα‖ · ‖F‖] ≥ −γ1
√ 3.
For sufficiently small γ1 this term is negligible, and since A (F) ≥ 0 we get that the expected risk is approximately the LHS term in Eq. (8). Lastly, recalling that (−43+2) = −ε we get that
(F() − min F ∈W (F) ≥ 1 2 ε +min
{ 1 − 2ε2 √ ), 0 } w.h.p.
The same lower bound (up to a constant) also holds in expectation by the the law of total expectation. Our distribution is supported on 5-Lipschitz convex functions, so that re-parametrizing 110ε→ ε as well as 5(6) yields the claimed lower bound (4) for the case of span-restricted algorithms.

heading: 3.3 Handling general full-batch algorithms
text: The above construction establishes an Ω(1/ε4) oracle complexity lower bound on any algorithm whose iterates lie in the span of the previous gradients. While this covers a large class of algorithms, techniques like preconditioning [13], coordinate methods [27] and randomized smoothing [14] do not satisfy this assumption. In fact, a trivial algorithm that always outputs −43+2 will solve the hard instance (6) in a single iteration. To address general algorithms, we employ a well-established technique in optimization lower bounds [30, 8, 12] wherein we embed a hard instance 5 (F; I) for span-constrained algorithms in a random high-dimensional space. More concretely, we draw a random orthogonal matrix * ∈ ℝ3′×3 (*>* = 3×3) and consider the 3 ′ > 3-dimensional instance 5* (F; I) = 5 (*>F; I) along with its corresponding empirical objective (,* (F) = 1= ∑ 8∈[=] 5* (F; I8). Roughly speaking, we show that for a general algorithm operating with the appropriate subgradient oracle for (,* the iterate FC is approximately in the span of {∇ (,* (F0), . . . ,∇ (,* (FC−1)} in the sense that the component of FC outside that span is nearly orthogonal to the columns of*. Consequently, the response of the oracle to the query FC at iteration C is, with high probability, identical to the information it would return if queried with the projection of FC to the span of the previously observed gradients. This reduces, in a sense, the problem back to the span-restricted setting described above. For the embedding technique to work, we must robustify the hard instance construction so that small perturbations around points in the span of previous gradients do not “leak” additional information about the embedding *. To do that we make a fairly standard modification to the component A (F) in (6) (known as Nemirovski’s function [12, 7]), replacing it with max{0,max8∈[3 ]{F(8) + 8γ′}, F(3 + 1) + γ′′}, where γ′, γ′′ are small offset coefficients that go to zero as the embedding dimension 3 ′ tends to infinity. We provide the full construction and the proof of Theorem 2.1 in Section 4 and the full version of the paper [1].

heading: 4 The Full Construction
text: As explained above, the key difference between the simplified construction 5(6) and the full construction with which we prove Theorem 2.1 is that we modify the Nemirvoski function term A (F) in order to make it robust to queries that are nearly within a certain linear subspace. In particular, we bias the different terms in the maximization defining A (F) so as to control the index of the coordinate attaining the maximum. For ease of reference, we now provide a self-contained definition of our full construction with the modified Nemirovski function. Fix =, 3 ≥ 1 and parameters I = (α, ε, γ) ∈ {0, 1}3 × ℝ × ℝ3 = Z are such that α ∈ {0, 1}3 , ε > 0 and γ1, γ2, γ3 > 0. Define the hard instance 5(9) : ℝ3+2 ×Z→ ℝ as follows:
5(9) (F; (α, ε, γ)) = 6γ(F;α) + γ1Eα · F + εF · 43+2 + A (F), (9)
where 6γ, Eα and A are
• 6γ(F;α) := √∑ 8∈[3 ] α(8)ℎ2γ(F(8)) with ℎγ(0) := { 0 0 ≥ −γ2; 0 + γ2 0 < −γ2,
• A (F) := max{0,max8∈[3+1]{F(8) + σ8}} with σ8 := { 8 · γ1γ343= if 8 ∈ [3]; 2γ3 if 8 = 3 + 1.
• Eα (8) :=  − 12= if α(8) = 0; +1 if α(8) = 1; 0 if 8 ∈ {3 + 1, 3 + 2},
and 48 is the 8’th standard basis vector in ℝ3+2. We consider a distribution over α that is distributed uniformly over {0, 1}3; that is, we draw α ∈ {0, 1}3 uniformly at random and pick the function 5(9) (F; (α, ε, γ)). The rest of the parameters are set throughout the proof as follows:
γ1 = εγ2 4 , γ2 = ε ) √ 3 , γ3 = ε 16 . (10)
With this choice of distribution as well our choice of parameters we obtain, since ‖Eα‖ ≤ √ 3 and by our choice of γ1 (as well as Jensen’s inequality and A (·) ≥ 0):
(F) = E α∼
[ 5(9) (F; (α, ε, γ)) ] ≥ 1
2 √∑ 8∈[3 ] ℎ2γ(F(8)) + εF(3 + 2) − ε 4 . (11)
Notice that we also have that for a choice F★ = −43+2, since A (F★) = 2γ3:
(F★) = −ε + ε 8 = −7ε 8 (12)
Our development makes frequent use of the following notation from Section 3:
I(() = {8 : α(8) = 0 ∀α ∈ (} ∪ {3 + 1}, IC (() = C largest elements in I((), and Ē = 1 = ∑ α∈( Eα.
We begin with the following lemma, which is a robust version of Lemma 3.1 in Section 3. The proof is provided in the full version of the paper [1]. Lemma 4.1. Suppose that F0 = 0. Consider 5(9) (F; (α, ε, γ)) with parameters as in Eq. (10). Suppose ( is a sample such that |I(() | > C + 1. Assume that F is such that
F = FC + @,
where
FC ∈ span1 8∈IC (()
{ γ1Ē + ε43+2 + 48 } , and ‖@‖∞ ≤ min {γ2 3 , γ1γ3 163= } . (13)
Then, ∇ ( (F) = γ1Ē + ε43+2 + 48 ,
for some 8 ∈ IC+1 ((), where IC (() is the set of the C + 1 largest coordinates in I(().
The following corollary states that the gradient oracle’s answers are resilient to small perturbation of the query (as long as they are in vicinity of the “right" subspace): the proof is provided in the full version of the paper [1]: Corollary 4.2. Assume that F is such that
F = FC + @,
where
FC ∈ span1 8∈IC (()
{ γ1Ē + ε43+2 + 48 } , and ‖@‖∞ ≤
1 4 √ 3
min {γ2
3 , γ1γ3 163=
} . (14)
Then, ∇ ( (F) = ∇ ( (ΠC+1 (F)), ( (F) = ( (ΠC+1 (F)),
where ΠC is a projection onto span8∈IC (() {γ1Ē + ε43+2 + 48}.
Acknowledgements and Disclosure of Funding
This work has received support from the Israeli Science Foundation (ISF) grant no. 2549/19 and grant no. 2188/20, from the Len Blavatnik and the Blavatnik Family foundation, from the Yandex Initiative in Machine Learning, and from an unrestricted gift from Google. Any opinions, findings, and conclusions or recommendations expressed in this work are those of the author(s) and do not necessarily reflect the views of Google.

Review summaries:
This paper considers a problem where one is trying to find an input that minimizes the expected value of a function that one has sample values of. Its goal is to show that algorithms that only have the ability to query the gradient of the average of the samples at specified points may need more queries than a function that can check the gradient on individual samples. In order to do that, the paper finds a class of probability distributions over functions for which any algorithm that gains information on the functions only by querying the gradient of the average of the sampled function needs $\Omega(1/\epsilon^4)$ queries to get within $\epsilon$ of the minimum expected loss.

In this paper the authors prove an error lower-bound for full-batch first-order algorithms. This is a generalization of the bound given in Bassily et al. [2]. This new bound of the authors - is true for a wider class of functions : GD and SGD, non-smooth and convex  - implies that to get an $\epsilon$-risk, full-batch methods require at least $\Omega (1/\epsilon^4)$ iterations This shows the advantage of stochastic methods like SGD which only require $\Omega (1/\epsilon^2)$ iterations to reach the same risk.

 The paper provides a lower bound on the iteration complexity of any full batch algorithm in stochastic convex optimization. In particular, they show that for every T, there exists a function (which depends on T) for which the suboptimality in terms of excess risk for any full batch algorithm run for T steps is lower bounded by 1/T^{1/4}. The proof technique extends upon the lower bound construction of Amir et. al. 2021 [1] for the iteration complexity of GD algorithm, and is based on a span based argument.  

This work studies the generalization performance of algorithms in stochastic convex optimization. Specifically, the authors study the full-batch algorithms where only full gradient and function value information are accessible. By constructing a hard instance of the objective function, the authors show that any full-batch algorithm needs at least $\Omega(1/\epsilon^4)$ iterations to obtain an $\epsilon$-risk function, while stochastic algorithms such as SGD only need $O(1/\epsilon^2)$.