Online Frank-Wolfe with Arbitrary Delays
Abstract
The online Frank-Wolfe (OFW) method has gained much popularity for online convex optimization due to its projection-free property.
Previous studies show that
OFW can attain an O ( T 3 / 4 ) regret bound for convex losses and an O ( T 2 / 3 ) regret bound for strongly convex losses.
However, they assume that each gradient queried by OFW is revealed immediately, which may not hold in practice and limits the application of OFW.
To address this limitation, we propose a delayed variant of
OFW, which allows gradients to be delayed by arbitrary rounds.
The main idea is to perform an update similar to OFW after receiving any delayed gradient, and play the latest decision for each round.
Despite its simplicity, we prove that our delayed variant of OFW is able to achieve an O ( T 3 / 4 + dT 1 / 4 ) regret bound for convex losses and an O ( T 2 / 3 + d log T ) regret bound for strongly convex losses, where d is the maximum delay.
This is quite surprising since under a relatively large amount of delay (e.g., d = O ( √ T ) for convex losses and d = O ( T 2 / 3 / log T ) for strongly convex losses), the delayed variant of OFW enjoys the same regret bound as that of the original OFW.
Introduction
Online convex optimization (OCO) has become a leading paradigm for online learning due to its capability to model various problems from diverse domains such as online routing, online collaborative ﬁltering and online advertisement [Hazan, 2016].
In general, it is formulated as a structured repeated game between a player and an adversary.
In each round t , the player ﬁrst chooses a decision x t from a convex decision set K ⊆ R n , where n is the dimensionality.
Then, the adversary selects a convex function f t ( x ) : K (cid:55)→ R , and the player suffers a loss f t ( x t ) .
The player aims to choose decisions such that the regret R ( T ) =
(cid:80) Tt =1 f t ( x t ) − min x ∈K (cid:80)
Tt =1 f t ( x ) is sublinear in the number of total rounds T .
Online gradient descent (OGD) is a standard method for OCO, which enjoys an O ( √ T ) regret bound for convex losses [Zinkevich, 2003] and an O (log T ) regret bound for strongly convex losses [Hazan et al., 2007].
However, it needs to compute a projection onto the decision set to ensure the feasibility of each decision, which is computationally expensive for complex decision sets [Hazan and Kale, 2012].
To tackle this computational issue, Hazan and Kale [2012] propose the online Frank-Wolfe (OFW) method, which has become one of the most commonly used algorithms for OCO over complex decision sets.
The main advantage of OFW is its projection-free property: instead of performing the projection operation, it utilizes a linear optimization step to select a feasible decision, which could be much more efﬁcient.
For example, in the problem of online collaborative ﬁltering, the decision set consists of matrices with a bounded trace norm, and the linear optimization step is at least an order of magnitude faster than the projection operation [Hazan and Kale, 2012].
Moreover, it has been shown that OFW achieves an O ( T 3 / 4 ) regret bound for convex losses [Hazan and Kale, 2012, Hazan, 2016] and an O ( T 2 / 3 ) regret bound for strongly convex losses [Wan and Zhang, 2021, Garber and
Kretzu, 2021], which are the best known regret bounds of projection-free methods without further assumptions.
However, OFW requires that the gradient ∇ f t ( x t ) is revealed immediately after making the decision x t , which is not necessarily satisﬁed in reality.
For example, in the previously mentioned online collaborative ﬁltering [Hazan and Kale, 2012], the decision is a prediction of a user-item rating matrix, and the corresponding gradient depends on the true rating of a user on a item, which may not be decided by the user immediately.
Therefore, it is natural to consider a more practical setting, where the gradient ∇ f t ( x t ) arrives at the end of round t + d t − 1 , and d t ≥ 1 denotes an arbitrary delay.
To handle this setting, one potential way is to combine OFW with an existing black-box technique for converting any traditional OCO algorithm into this delayed setting [Joulani et al., 2013].
To be precise, this black-box technique is to pool independent instances of OFW, each of which acts as a learner in the non-delayed setting over a subsequence of rounds.
In each round, a single instance will be taken out from the pool, which makes a decision and then waits for its feedback before rejoining the pool.
If the pool is empty, a new instance of OFW will be added to it.
Moreover, according to Joulani et al.
[2013], their black-box technique is able to attain a regret bound of dR ( T/d ) by combining with a traditional OCO algorithm with R ( T ) regret, where d is the maximum delay.
As a result, combining it with OFW will attain an O ( d 1 / 4 T 3 / 4 ) regret bound for convex losses and an
O ( d 1 / 3 T 2 / 3 ) regret bound for strongly convex losses, which magnify the regret bounds of OFW in the non-delayed setting by a coefﬁcient depending the delay.
Thus, it is natural to ask whether the effect of delay can be further reduced.
In this paper, we give an afﬁrmative answer by developing a simple method called delayed OFW, which is robust to a relatively large amount of delay for both convex and strongly convex losses.
Different from the black-box technique that needs to maintain multiple instances of OFW
[Joulani et al., 2013], our delayed OFW is a natural extension of OFW in the delayed setting, which updates the decision similar to OFW after receiving any delayed gradient, and plays the latest decision for each round.
Our theoretical contributions are summarized as follows.
• First, we prove that our delayed OFW attains an O ( T 3 / 4 + dT 1 / 4 ) regret bound for convex losses, where d is the maximum delay, which matches the O ( T 3 / 4 ) regret bound in the non-delayed setting as long as d does not exceed O ( √ T ) .
Second, we prove that our delayed OFW attains an O ( T 2 / 3 + d log T ) regret bound for strongly convex losses, which matches the O ( T 2 / 3 ) regret bound in the non-delayed setting as long as d does not exceed O ( T 2 / 3 / log T ) .
Therefore, our regret bounds are strictly better than those achieved by combining the black-box technique [Joulani et al., 2013] with OFW, when the term involving d in them is not dominant.
Furthermore, simulation experiments are conducted to verify the performance of our delayed OFW.
Related work
In this section, we brieﬂy review related work on projection-free algorithms for OCO, and OCO under delayed feedback.
2.1 Projection-free algorithms for OCO
The OFW method [Hazan and Kale, 2012, Hazan, 2016] is the ﬁrst projection-free algorithm for
OCO, which is an online extension of the classical Frank-Wolfe method [Frank and Wolfe, 1956,
Jaggi, 2013].
For convex losses, OFW ﬁrst chooses an arbitrary x 1 ∈ K , and then iteratively updates its decision by the following linear optimization step
[Equation]
where F t ( x ) is a surrogate loss function deﬁned as
[Equation]
and η, σ t are two parameters.
By setting parameters appropriately, it can attain an O ( T 3 / 4 ) regret bound for convex losses.
If losses are convex and smooth, Hazan and Minasyan [2020] propose a randomized projection-free method, which is based on a classical OCO method called follow the perturbed leader [Kalai and
Vempala, 2005], and achieve a regret bound of O
( T 2 / 3 ) .
Recently, Wan and Zhang [2021] prove that
OFW can achieve an O ( T 2 / 3 ) regret bound for strongly convex losses.
Speciﬁcally, to utilize the strong convexity of losses, they redeﬁne F t ( x ) in (2) to
[Equation]
where β is the modulus of the strong convexity.
The same regret bound is concurrently established by
Garber and Kretzu [2021] in a similar way.
Moreover, projection-free OCO algorithms, which are able to achieve an O ( √ T ) regret bound for convex losses and an O (log T ) regret bound for strongly convex losses, have been proposed for polyhedral sets [Garber and Hazan, 2016], smooth sets [Levy and Krause, 2019], and special sets that are accessible through a membership oracle [Mhammedi, 2022] or a separation oracle [Garber and Kretzu, 2022], respectively.
Although regret bounds of these algorithms are better than those of OFW, they can only be efﬁciently implemented in some special cases, and thus are still not able to replace OFW.
In addition to these algorithms, Wan and Zhang [2021] show that by setting σ t with a line search technique, OFW can adaptively utilize the strong convexity of decision sets to attain an O ( T 2 / 3 ) regret bound for convex losses and an O ( √ T ) regret bound for strongly convex losses.
Besides the standard setting, projection-free algorithms for other OCO scenarios such as the distributed setting [Zhang et al., 2017, Wan et al., 2020, 2022b] and the bandit setting [Chen et al., 2019, Garber and Kretzu, 2020, 2021] have also been proposed.
However, despite this great ﬂourish of research on projection-free OCO algorithms, the practical problem of delayed feedback has not been considered.
2.2 OCO under delayed feedback
The starting point for studies on OCO under delayed feedback is the seminal work of Weinberger and
Ordentlich [2002], which focuses on a special case with a ﬁxed delay d (cid:48) , i.e., the feedback for each decision x t is received at the end of round t + d (cid:48) − 1 .
They propose a technique that can convert any traditional OCO algorithm for the non-delayed setting into this delayed setting.
Speciﬁcally, their technique is to run d (cid:48) instances of a traditional OCO algorithm, where each instance is used every d (cid:48) rounds, which is feasible because the feedback for any decision x t must be available for selecting the decision x t + d (cid:48) .
If the traditional OCO algorithm enjoys a regret bound of R ( T ) in the non-delayed setting, they prove that this technique achieves a regret bound of d (cid:48)
R ( T/d (cid:48) ) .
As a result, by combining with OGD, the regret bound of this technique is O ( √ d (cid:48) T ) for convex losses and O ( d (cid:48) log T ) for strongly convex losses.
However, it needs to run d (cid:48) instances of OGD, which requires more storage and computational resources than the original OGD.
To address this problem,
Langford et al.
[2009] study the same delayed setting, and show that simply performing each gradient descent step in the original OGD with a delayed gradient can also achieve the O ( √ d (cid:48) T ) regret bound for convex losses and the O ( d (cid:48) log T ) regret bound for strongly convex losses.
Furthermore, Joulani et al.
[2013] extend the technique in Weinberger and Ordentlich [2002] to handle a more general setting, where each feedback is delayed by arbitrary rounds.
For this setting, their technique is able to attain a regret bound of dR ( T/d ) by combining with a traditional OCO algorithm with R ( T ) regret, where d is the maximum delay.
Note that although this technique can also convert
OFW to the delayed setting, it can only attain an O ( d 1 / 4 T 3 / 4 ) regret bound for convex losses and an
O ( d 1 / 3 T 2 / 3 ) regret bound for strongly convex losses, which cannot match regret bounds of OFW in the non-delayed setting as long as d is larger than Ω(1) .
Additionally, similar to the technique in Weinberger and Ordentlich [2002], it also needs to run multiple instances of a traditional OCO algorithm, which could be prohibitively resource-intensive.
Many studies [Quanrud and Khashabi, 2015, Joulani et al., 2016, Li et al., 2019, Flaspohler et al., 2021, Wan et al., 2022a] have proposed delayed OCO algorithms, which only require the same storage and computational resources as in the non-delayed setting, but do not consider projection-free algorithms.
Main results
In this section, we ﬁrst introduce necessary preliminaries including the problem setting, deﬁnitions, and assumptions.
Then, we present our delayed OFW and the corresponding theoretical guarantees for convex and strongly convex losses, respectively.
3.1 Preliminaries
We consider the problem of OCO with arbitrary delays [Joulani et al., 2013, Quanrud and Khashabi, 2015].
Similar to the standard OCO, in each round t = 1 , . .
, T , the player ﬁrst chooses a decision x t from the decision set K , and then the adversary selects a convex function f t ( x ) .
However, different from the standard OCO, the gradient g t = ∇ f t ( x t ) is revealed at the end of round t + d t − 1 , where d t ≥ 1 denotes an arbitrary delay.
As a result, the player actually receives gradients { g k | k ∈ F t } at the end of round t , where F t = { k | k + d k − 1 = t } .
Then, we recall the standard deﬁnition for strongly convex functions [Boyd and Vandenberghe, 2004].
Deﬁnition 1 A function f ( x ) : K → R is called β -strongly convex over K if for all x , y ∈ K , it holds that f ( y ) ≥ f ( x ) + (cid:104)∇ f ( x ) , y − x (cid:105) + β 2 (cid:107)
y − x (cid:107) 22 .
Finally, we introduce two assumptions, which are commonly used in studies about OCO [ShalevShwartz, 2011, Hazan, 2016].
Assumption 1 The gradients of all loss functions are bounded by G , i.e., it holds that (cid:107)∇ f t ( x ) (cid:107) 2 ≤
G for any x ∈ K and t ∈ [ T ] .
Assumption 2 The diameter of the decision set K is bounded by D , i.e., it holds that (cid:107) x − y (cid:107) 2 ≤ D for any x , y ∈ K .
3.2 Delayed OFW for convex losses
As presented in (1) and (2), the original OFW for convex losses requires the gradient g t before making the decision x t +1 .
However, in the problem of OCO with arbitrary delays, this requirement is not necessarily satisﬁed, because the player actually receives gradients { g k | k ∈ F t } at each round t , which may not contain g t .
To address this limitation, we propose a natural generalization of OFW to this delayed problem, which is described as follows.
The main idea is to update the decision similar to OFW for each received gradient, and play the latest decision for each round.
In this way, there exist some intermediate decisions that are not really played.
To facilitate presentations, we introduce an additional notation y τ to denote the τ -th intermediate decision.
Moreover, we denote the sum of τ received gradients by ¯ g τ .
Initially, we choose an arbitrary vector y 1 ∈ K and set τ = 1 , ¯ g 0 = 0 .
At each round t = 1 , . . .
, T , we play the latest decision x t = y τ and query the gradient g t = ∇ f t ( x t ) .
Then, we receive delayed gradients that are queried in a set of rounds F t , and perform the following steps for each received gradient.
Speciﬁcally, for any k ∈ F t , inspired by (2) of the original OFW, we ﬁrst compute ¯ g τ = ¯ g τ − 1 + g k and deﬁne
[Equation]
Then, similar to (1) of the original OFW, we perform the following update
[Equation]
where σ τ is a parameter.
Following Wan and Zhang [2021]
[Equation]
it is set by a line search rule
[Equation]
1: Input: η 2: Initialization: choose an arbitrary vector y 1 ∈ K and set τ = 1 , ¯ g 0 =3: for t = 1 , 2 , . .
, T do 4:
Play x t = y τ and query g t = ∇ f t ( x t ) 5:
Receive a set of delayed gradients { g k | k ∈ F t } 6: for k ∈ F t do 7:
Update ¯ g τ = ¯ g τ − 1 + g k and deﬁne F τ ( y )
=
η (cid:104)
¯ g τ , y (cid:105)
+ (cid:107) y − y 1 (cid:107)8:
Compute v τ ∈ argmin y ∈K (cid:104)∇ F τ ( y τ ) , y (cid:105) 9:
Update y
τ
+
=
y τ
+ σ τ ( v τ − y τ ) with σ τ in (4) and set τ = τ +10: end for 11: end for
Finally, we update τ = τ + 1 so that τ still indexes the latest intermediate decision.
The detailed procedures are summarized in Algorithm 1, which is named as delayed OFW for convex losses.
Let d = max { d 1 , . . .
, d T } .
We establish the following theorem with respect to the regret of
Algorithm 1.
Theorem 1 For any x ∗ ∈ K , under Assumptions 1 and 2, Algorithm 1 with η =
D √ 2 G
( T +2) 3 / 4 has
[Equation]
Theorem 1 shows that without knowing the value of d , our Algorithm 1 can attain an O ( T 3 / 4 + dT 1 / 4 ) regret bound for convex losses with arbitrary delays.
This bound matches the O ( T 3 / 4 ) regret bound of OFW in the non-delayed setting [Hazan, 2016], as long as d does not exceed O ( √ T ) .
Moreover, it is better than the O ( d 1 / 4 T 3 / 4 ) regret bound achieved by combining the technique of Joulani et al.
[2013] and the O ( T 3 / 4 ) regret bound of OFW for convex losses, as long as d does not exceed
O ( T 2 / 3 ) .
3.3 Delayed OFW for strongly convex losses
We proceed to handle β -strongly convex losses by slightly modifying Algorithm 1.
Recall that in the standard OCO without delays, the critical idea of utilizing the strong convexity of losses is to replace the surrogate loss function in (1) by that in (3)
[Wan and Zhang, 2021].
The main difference is that the regularization term in (3) is about all historical decisions, instead of only the initial decision.
Inspired by (3), we ﬁrst redeﬁne F τ ( y ) in Algorithm 1 to
[Equation]
Second, since F τ ( y ) is modiﬁed, we adjust the line search rule to
[Equation]
The detailed procedures are summarized in Algorithm 2, which is named as delayed OFW for strongly convex losses.
Then, we establish the following theorem about the regret of Algorithm 2.
Theorem 2 Suppose all losses are β -strongly convex and Assumptions 1 and 2 hold.
For any x ∗ ∈ K ,
Algorithm 2 has
T (cid:88)
[Equation]
Theorem 2 shows that our Algorithm 2 can attain an O ( T 2 / 3 + d log T ) regret bound for strongly convex losses with arbitrary delays.
First, this bound is better than the O ( T 3 / 4 + dT 1 / 4 ) regret bound
1: Input: β 2: Initialization: choose an arbitrary vector y 1 ∈ K and set τ = 1 , ¯ g 0 =3: for t = 1 , 2 , . .
, T do 4:
Play x t = y τ and query g t = ∇ f t ( x t ) 5:
Receive a set of delayed gradients { g k | k ∈ F t } 6: for k ∈ F t do 7:
Update ¯ g τ = ¯ g τ − 1 + g k and deﬁne F τ ( y )
=
(cid:104)
¯ g τ , y (cid:105)
+ (cid:80) τi
=1 β 2 (cid:107)
y − y i (cid:107)8:
Compute v τ ∈ argmin y ∈K (cid:104)∇ F τ ( y τ ) , y (cid:105) 9:
Update y
τ
+
=
y τ
+ σ τ ( v τ − y τ ) with σ τ in (5) and set τ = τ +10: end for 11: end for in Theorem 1, which is established by only using the convexity condition.
Second, it matches the
O ( T 2 / 3 ) regret bound of OFW for strongly convex losses in the non-delayed setting [Wan and Zhang, 2021], as long as d does not exceed O
( T 2 / 3 / log T ) .
Third, it is better than the O ( d 1 / 3 T 2 / 3 ) regret bound achieved by combining the technique of Joulani et al.
[2013] and the O ( T 2 / 3 ) regret bound of
OFW for strongly convex losses, as long as d does not exceed O ( T/ (log T ) 3 / 2 ) .
Theoretical analysis
In this section, we ﬁrst introduce some insights and preliminaries for our analysis, and then prove
Theorems 1 and 2 by introducing some lemmas.
Due to the limitation of space, the proofs for those lemmas are provided in the appendix.
4.1 Insights and preliminaries
Note that in the non-delayed setting, the regret bound of OFW is worse than that of OGD due to the gap between the linear optimization step and the projection operation.
Thus, in the delayed setting, it is natural to conjecture that both the linear optimization step and the delay will affect the regret of our delayed OFW.
To keep the same regret bound as the original OFW, our key insight is to prove that the combined effect of the linear optimization step and the delay can be additive, instead of being multiplicative, and the effect of the delay can be weaker than that of the linear optimization step for a relatively large amount of delay.
Moreover, there are some necessary preliminaries for our analysis.
First, because of the effect of delays, there may exist some gradients that arrive after round T .
Although our Algorithms 1 and 2 do not need to use these gradients, they are useful for the analysis.
As a result, in our analysis, we further set x t = y τ and perform steps 5 to 10 of Algorithms 1 and 2 for any t = T +1 , . .
, T + d − 1 .
In this way, all gradients g 1 , g 2 , . .
. , g T queried by our algorithms are utilized, which produces decisions y 1 , y 2 , . .
, y T +1 .
Then, let τ t = 1 + (cid:80) t − 1 i =1 |F i | for any t ∈
[ T + d ] .
It is not hard to verify that our Algorithms 1 andensure that x t = y τ t (6) for any t ∈
[ T + d − 1] .
Next, we deﬁne
I t = (cid:26) ∅ , if |F t | = 0 , { τ t , τ t + 1 , . . .
, τ t +1 − 1 } , otherwise .
Let s = min { t
| t ∈
[ T + d − 1] , |F t | > 0 } .
It is not hard to verify that ∪
[Equation]
[Equation]
To facilitate the analysis, we further denote the time-stamp of the τ -th gradient used in the update of our Algorithms 1 and 2 by c τ .
To help understanding, one can imagine that our Algorithms 1 andalso implement c τ = k in their step 7 .
If |F t | (cid:54) = 0 , we have { c τ t , . . .
, c
τ t +1 − 1 } = F t .
By using this notation, F τ ( y ) deﬁned in Algorithms 1 and 2 are respectively equivalent to
[Equation]
4.2 Proof of Theorem
Let t (cid:48)
=
t + d t − 1 for any t ∈ [ T ] .
According to the convexity of f t ( x ) , we have
[Equation]
where the last equality is due to (6)
[Equation]
Let A = (cid:80)
Tt =1 G
[Equation]
y τ t − y τ t
[Equation]
(cid:107) 2 .
By summing over t = 1 , . . .
, T , we have
[Equation]
Then, we bound the ﬁrst term in the right side of (13) as follows
T
[Equation]
where the ﬁrst equality is due to (9), the second equality is due to i + d i − 1 = t for any i ∈ F t , the third equality is due to (10), and the last equality is due to (7) and (8).
Then, let B =
(cid:80) Tt =1 (cid:104)
g c t , y t − x ∗ (cid:105) and C = (cid:80) T + d − 1 t
=
s (cid:80) τ
t +1 − 1 i = τ t
G (cid:107) y τ t − y
i
(cid:107) 2 .
By combining (13), (14), and (cid:104)
g c i , y τ t − y i (cid:105) ≤ G (cid:107)
y τ t − y
i
(cid:107) 2 , we have
T (cid:88) t = f
[Equation]
( x
[Equation]
(cid:88)
[Equation]
+
[Equation]
+ C.
Next, we proceed to bound terms A , B , and C .
Speciﬁcally, we ﬁrst establish the following bound for the sum of terms A and C by carefully analyzing the distance (cid:107)
y τ t − y τ t (cid:48) (cid:107) 2 in the term A and the distance (cid:107)
y τ t − y
i
(cid:107) 2 in the term C .
Lemma 1 Let y ∗ t = argmin
y ∈K F t − 1 ( y ) for any t ∈
[ T + 1] , where F t ( y ) is deﬁned in (11).
Suppose Assumption 1 and 2 hold, and there exist some constants γ > 0 and 0 < α ≤ 1 such that
F t − 1 ( y t ) − F t − 1 ( y ∗ t ) ≤ γ ( t + 2) − α for any t ∈
[ T + 1] .
Algorithm 1 ensures
[Equation]
where A = (cid:80) T t =1 G (cid:107)
y τ t − y τ t (cid:48) (cid:107) 2 and C =
(cid:80) T + d − 1 t
=
s (cid:80) τ
t +1 − 1 i = τ t
G (cid:107) y τ t − y
i
(cid:107) 2 .
Note that Lemma 1 introduces an assumption about y t and F t − 1 ( y ) .
According to our Algorithm 1, y t is actually generated by approximately minimizing F t − 1 ( y ) with a linear optimization step.
Therefore, by following the analysis of the original OFW [Hazan, 2016], we show that this assumption can be satisﬁed with γ = 8 D 2 and α = 1 / 2 .
Lemma 2 Let y ∗ t = argmin
y ∈K F t − 1 ( y ) for any t ∈
[ T +1] , where F t ( y ) is deﬁned in (11).
Under
Assumptions 1 and 2, for any t ∈
[ T + 1] , Algorithm 1 with η =
[Equation]
Then, by combining η =
[Equation] [Equation]
4 with Lemmas 1 and 2, we have
[Equation]
Furthermore, by following the analysis of the original OFW [Hazan, 2016], we establish an upper bound for the term B .
Lemma 3 Under Assumptions 1 and 2, for any x ∗ ∈ K , Algorithm 1 with η =
[Equation]
[Equation] [Equation]
4 ensures
[Equation]
Finally, by combining (15), (16), and Lemma 3, we complete this proof.
4.3 Proof of Theorem
Since f t ( x ) is β -strongly convex, we have
[Equation]
Then, we note that the ﬁrst term in the right side of (17) can be bounded by reusing (13) and (14).
Speciﬁcally, we have
[Equation]
where terms A and C are deﬁned in the proof of Theorem 1.
Next, we consider the last term in the right side of (18).
For any y t , x t , x ∗ ∈ K , we have
[Equation]
where the last inequality is due to 2 (cid:104)
y t − x t , x t − x ∗
[Equation]
≤
[Equation]
y t − x t (cid:107) 2 (cid:107) x
t − x ∗ (cid:107) 2 and Assumption 2.
Let B (cid:48) =
(cid:80) T t =1 (cid:104) g c t , y t − x ∗ (cid:105)− (cid:80) T t =1 β 2 (cid:107)
y t − x ∗ (cid:107) 22 and E =
(cid:80) T t =1 3 βD 2 (cid:107) y t
− y τ t (cid:107) 2 .
By combining the above inequality and (6) with (18), we have
[Equation]
Then, we proceed to establish upper bounds for terms A , C , and E by carefully analyzing the distance (cid:107) y τ t − y τ t (cid:48) (cid:107) 2 in the term A , the distance (cid:107)
y τ t − y
i
(cid:107) 2 in the term C , and the distance (cid:107) y t − y τ t (cid:107)in the term E .
Lemma 4 Let y ∗ t = argmin
y ∈K F t − 1 ( y ) for any t
= 2 , . .
, T + 1 , where F t ( y ) is deﬁned in (12).
Suppose Assumption 1 and 2 hold, all losses are β -strongly convex, and there exist some constants γ > 0 and 0 ≤ α < 1 such that F t − 1 ( y t ) − F t − 1 ( y ∗ t ) ≤ γ ( t − 1) α for any t
= 2 , . .
, T + 1 .
Algorithm 1 ensures
[Equation]
where A = (cid:80) Tt =
1 G (cid:107)
y τ t − y τ t (cid:48) (cid:107) 2 , C = (cid:80) T + d − 1 t
=
s (cid:80) τ
t +1 − 1 i = τ t
G (cid:107) y τ t − y
i
(cid:107) 2 , and E = (cid:80) Tt =1 3 βD 2 (cid:107) y t − y τ t (cid:107) 2 .
Note that Lemma 4 also introduces an assumption about y t and F t − 1 ( y ) .
According to our Algorithm 2, y t is actually generated by approximately minimizing F t − 1 ( y ) with a linear optimization step.
Therefore, by following the analysis of OFW for strongly convex losses [Wan and Zhang, 2021], we show that this assumption is satisﬁed with γ = 16( G + 2 βD ) 2 /β and α = 1 / 3 .
Lemma 5 Let y ∗ t = argmin
y ∈K F t − 1 ( y ) for any t
= 2 , . .
, T + 1 , where F t ( y ) is deﬁned in (12).
Suppose Assumption 1 and 2 hold, and all losses are β -strongly convex.
For any t = 2 , . . .
, T + 1 ,
Algorithm 2 has
[Equation]
By combining Lemmas 4 and 5, we have
[Equation]
Furthermore, by following the analysis of OFW for strongly convex losses [Wan and Zhang, 2021], we establish an upper bound for the third term in (19).
Lemma 6 Suppose Assumption 1 and 2 hold, and all losses are β -strongly convex.
For any x ∗ ∈ K ,
Algorithm 2 ensures
[Equation]
where B (cid:48)
= (cid:80) Tt =1 (cid:104)
g c t , y t − x ∗ (cid:105) − (cid:80) Tt =1 β 2 (cid:107)
y t − x ∗ (cid:107) 22 .
Finally, by combining (19), (20), and Lemma 6, we complete this proof.
Experiments
In this section, we conduct simulation experiments to verify the performance of our delayed OFW for convex losses and strongly convex losses.
All algorithms are implemented wtih Matlab R2017a and tested on a laptop with 2.4GHz CPU and 16GB memory.
The code is available from https: //github.com/yuanyuwan/NeurIPS22 .
Speciﬁcally, we consider a delayed OCO problem with T = 10000 total rounds over the decision set
K = (cid:8) x ∈ R 1000 (cid:12)(cid:12) (cid:107) x (cid:107) 1 ≤ 200 (cid:9) , which satisﬁes Assumption 2 with D = 400 due to (cid:107) x
− y (cid:107) 2 ≤ (cid:107) x
(cid:107)
+ (cid:107) y (cid:107) 2 ≤ (cid:107) x (cid:107) 1 + (cid:107) y (cid:107) 1 ≤ 400 for any x , y ∈ K .
Inspired by Li et al.
[2019], in each round t ∈ [ T ] , the adversary chooses the following loss function
[Equation]
where each element of b t ∈ R 1000 is independently and uniformly sampled from [ − 1 , 1] .
For any x ∈ K , since ∇ f t ( x ) = 2 x + b t , it is easy to verify that (cid:107)∇ f t ( x ) (cid:107) 2 ≤ 2 (cid:107) x (cid:107) 2 + (cid:107) b t (cid:107) 2 ≤ 2 (cid:107) x (cid:107) 1 + (cid:107) b t (cid:107) 2 ≤ 400 + √ 1000 , which implies that this loss function satisﬁes Assumption 1 with
G = 400 + √ 1000 .
We also notice that this loss function satisﬁes the deﬁnition of β -strongly convex function (i.e., Deﬁnition 1) with β = 2 .
Moreover, different values of the maximum delay d in the set { 1 , 51 , 101 , . .
. , 501 } are tried in our experiments.
For each speciﬁc d , to simulate arbitrary delays, d t is independently and uniformly sampled from the set {(cid:100) 0 .
1 d (cid:101) , (cid:100) 0 .
1 d (cid:101) + 1 , (cid:100) 0 .
1 d (cid:101) + 2 , . . .
, d } .
We compare our proposed algorithms against the combination of the technique in Joulani et al.
[2013] and OFW.
Our delayed OFW for convex losses and strongly convex losses are denoted as DOFW (i.e.,
Algorithm 1) and DOFW sc (i.e., Algorithm 2), respectively.
Similarly, since the technique in Joulani et al.
[2013] is named as black-box online learning under delayed feedback (BOLD), we denote the combination of BOLD with OFW for convex losses and strongly convex losses as BOLD-OFW and
BOLD-OFW sc , respectively.
The parameters of all algorithms are set as what their corresponding theories suggest.
Speciﬁcally, according to our Theorems 1 and 2, we set η =
D √ 2 G
( T +2) 3 / 4 for our DOFW and set β = 2 for our DOFW sc .
According to Joulani et al.
, BOLD-OFW
[Figure]
and BOLD-OFW sc will maintain several instances of OFW for convex and strongly convex losses, respectively.
Note that in the non-delayed case with d = 1 our delayed OFW actually reduces to the original OFW.
Therefore, our Theorems 1 and 2 can also be utilized to choose the parameters for each instance of OFW maintained in BOLD-OFW and BOLD-OFW sc .
To be precise, in BOLD-OFW, we set η =
[Equation]
3 / 4 for each instance of OFW for convex losses, since the total rounds of each instance is roughly T/d .
In BOLD-OFW sc , we only need to set β = 2 for each instance of OFW for strongly convex losses.
Moreover, for our delayed OFW and each instance of OFW, the initial decision is set to 1 / 50 , where 1 denotes the all-ones vector.
Fig.
1(a) shows the total loss of T rounds for each algorithm under different values of the maximum delay d .
First, when d = 1 , the total loss of our DOFW is the same as that of BOLD-OFW and the total loss of our DOFW sc is the same as that of BOLD-OFW sc , which is reasonable because in this case DOFW and BOLD-OFW reduce to the original OFW for convex losses, and DOFW sc and BOLDOFW sc reduce to the original OFW for strongly convex losses.
Second, for d = 51 , 101 , 151 , . .
, 501 , our DOFW and DOFW sc are better than BOLD-OFW and BOLD-OFW sc respectively, which clearly veriﬁes the advantage of our algorithms in the delayed setting.
It is worthy to notice that d =is larger than T 2 / 3 .
Moreover, for our DOFW and DOFW sc , when d increases from 1 to 501 , the growth of the total loss is very slow, which is consistent with the dependence of our regret bounds on d . Fig. 1(b) shows the cumulative loss for each algorithm when d = 501 .
As the number of iterations increases, the cumulative loss of BOLD-OFW and BOLD-OFW sc increase much faster than that of our algorithms.
Conclusion and future work
In this paper, we propose delayed OFW for OCO with arbitrary delays.
For convex losses, we show that it attains an O ( T 3 / 4 + dT 1 / 4 ) regret bound, which matches the O ( T 3 / 4 ) regret bound of OFW in the non-delayed setting, as long as d does not exceed O ( √ T ) .
When losses are strongly convex, we further prove that it can attain an O ( T 2 / 3 + d log T ) regret bound, which matches the O ( T 2 / 3 ) regret bound of OFW in the non-delayed setting, as long as d does not exceed O ( T 2 / 3 / log T ) .
Simulation experiments demonstrate the performance of delayed OFW in the delayed setting.
This paper only extends the classical OFW to the delayed setting.
In the future, we will investigate how to develop delayed variants for other projection-free online algorithms.
Acknowledgments
This work was partially supported by NSFC (61921006, 62122037), and JiangsuSF (BK20200064).
[-Deﬁnition 
-]