Dynamic Regret of Strongly Adaptive Methods
Lijun Zhang Tianbao Yang Rong Jin Zhi-Hua Zhou








Dynamic Regret of Strongly Adaptive Methods
    Lijun Zhang zhanglj@lamda.nju.edu.cn

       National Key Laboratory for Novel Software Technology

       Nanjing University, Nanjing 210023, China
       Tianbao Yang tianbao-yang@uiowa.edu

       Department of Computer Science

       the University of Iowa, Iowa City, IA 52242, USA
       Rong Jin jinrong.jr@alibaba-inc.com

       Alibaba Group, Seattle, USA
       Zhi-Hua Zhou zhouzh@lamda.nju.edu.cn

       National Key Laboratory for Novel Software Technology

       Nanjing University, Nanjing 210023, China
    December 30, 2023
==============================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================




To cope with changing environments, recent developments in online learning have introduced the concepts of adaptive regret and dynamic regret independently. In this paper, we illustrate an intrinsic connection between these two concepts by showing that the dynamic regret can be expressed in terms of the adaptive regret and the functional variation. This observation implies that strongly adaptive algorithms can be directly leveraged to minimize the dynamic regret. As a result, we present a series of strongly adaptive algorithms that have small dynamic regrets for convex functions, exponentially concave functions, and strongly convex functions, respectively. To the best of our knowledge, this is the first time that exponential concavity is utilized to upper bound the dynamic regret. Moreover, all of those adaptive algorithms do not need any prior knowledge of the functional variation, which is a significant advantage over previous specialized methods for minimizing dynamic regret.



Online convex optimization, Adaptive regret, Dynamic regret






§ INTRODUCTION

Online convex optimization is a powerful paradigm for sequential decision making <cit.>. It can be viewed as a game between a learner and an adversary: In the t-th round, the learner selects a decision _t ∈Ω, simultaneously the adversary chooses a function f_t(·): Ω↦, and then the learner suffers an instantaneous loss f_t(_t).  This study focuses on the full-information setting, where the learner can query the value and gradient of f_t  <cit.>.  The goal of the learner is to minimize the cumulative loss over T periods . The standard performance measure is regret, which is the difference between the loss incurred by the learner and that of the best fixed decision in hindsight, i.e.,

    (T)=∑_t=1^T f_t(_t) - min_∈Ω∑_t=1^T f_t().


The above regret is typically referred to as static regret in the sense that the comparator is time-invariant. The rationale behind this evaluation metric is that one of the decision in Ω is reasonably good over the T rounds. However, when  the underlying distribution of loss functions
changes, the static regret may be too optimistic and fails to capture the hardness of the problem. 

To address this limitation, new forms of performance measure, including adaptive regret <cit.> and dynamic regret <cit.>, were proposed and received significant interest  recently.  Following the terminology of <cit.>, we define the strongly adaptive regret as the maximum static regret over intervals of length τ, i.e.,

    (T,τ) = max_[s, s+τ -1] ⊆ [T](∑_t=s^s+τ -1  f_t(_t)  - min_∈Ω∑_t=s^s+τ -1 f_t() ).

Minimizing the adaptive regret enforces the learner to have a small static regret over any interval of length τ. Since the best decision for different intervals could be different, the learner is essentially competing with a changing comparator. 

A parallel line of research introduces the concept of dynamic regret, where the cumulative loss of the learner is compared against a comparator sequence _̆1, …, _̆T ∈Ω, i.e.,

    (_̆1,…,_̆T) = ∑_t=1^T f_t(_t)  - ∑_t=1^T f_t(_̆t).

It is well-known that in the worst case, a sublinear dynamic regret is impossible unless we impose some regularities on the comparator sequence or the function sequence <cit.>. A representative example is the functional variation  defined below

    V_T = ∑_t=2^T max_∈Ω |f_t() - f_t-1()|.

<cit.> have  proved that as long as V_T is sublinear in T, there exists an algorithm that achieves a sublinear dynamic regret. Furthermore,  a general restarting procedure is developed, and it enjoys O(T^2/3V_T^1/3) and O(log T √(T V_T)) rates for convex functions and strongly convex functions, respectively. 
However, the restarting procedure can only be applied when an upper bound of V_T is known beforehand, thus limiting its application in practice.


While both the adaptive and dynamic regrets aim at coping with changing environments, little is known about their relationship. This paper makes a step towards understanding their connections. Specifically, we show that the strongly adaptive regret in (<ref>), together with the functional variation, can be used to upper bound the dynamic regret in (<ref>). Thus, an algorithm with a small strongly adaptive regret is automatically equipped with a tight dynamic regret. As a result, we obtain a series of algorithms for minimizing the dynamic regret that do not need any prior knowledge of the functional variation.  The main contributions of this work are summarized below.


  * We provide a general theorem that  upper bounds the dynamic regret in terms of the strongly adaptive regret and the functional variation.

  * For convex functions, we show that the strongly adaptive algorithm of <cit.> has a dynamic regret of  O(T^2/3 V_T^1/3log^1/3 T), which matches the minimax rate <cit.>,  up to a polylogarithmic factor.

  * For exponentially concave functions, we propose a strongly adaptive algorithm that allows us to control the tradeoff between the adaptive regret and the computational cost explicitly. Then, we demonstrate that its dynamic regret is O(d √(T V_T log T)), where d is the dimensionality. To the best of our knowledge, this is the first time that exponential concavity is utilized in the analysis of dynamic regret.

  * For strongly convex functions,  our proposed algorithm can also be applied and yields a dynamic regret of O(√(T V_T log T)), which is also minimax optimal up to a polylogarithmic factor.




§ RELATED WORK

We give a brief introduction to previous work on static, adaptive, and dynamic regrets in the context of online convex optimization.


 §.§ Static Regret

The majority of studies in online learning are focused on static regret <cit.>. For general convex functions, the classical online gradient descent achieves O(√(T)) and O(log T) regret bounds for convex and strongly convex functions, respectively <cit.>.  Both the O(√(T)) and O(log T) rates are known to be minimax optimal <cit.>. When functions are exponentially concave, a different algorithm, named online Newton step, is developed and enjoys an O(d log T) regret bound, where d is the dimensionality <cit.>.




 §.§ Adaptive Regret

The concept of adaptive regret is  introduced by <cit.>, and later strengthened  by <cit.>. Specifically,   <cit.> introduce the weakly adaptive regret

    (T)=  max_[s, q] ⊆ [T](∑_t=s^q f_t(_t) - min_∈Ω∑_t=s^q f_t()).

To minimize the adaptive regret, <cit.> have developed two meta-algorithms: an efficient algorithm with O(log T) computational complexity per iteration and an inefficient one with O(T) computational complexity per iteration. These meta-algorithms use an existing online method (that was possibly designed to have small static regret) as a subroutine.[For brevity, we ignored the factor of subroutine in the statements of computational complexities. The O(·) computational complexity should be interpreted as O(·) × s space complexity and O(·) × t time complexity, where s and t are  space  and time complexities of the subroutine per iteration, respectively.] For  convex functions, the efficient and inefficient meta-algorithms have   O(√(T log^3 T)) and O(√(T log T)) regret bounds, respectively. For exponentially concave functions, those rates are improved to  O(d log^2 T) and O(d log T), respectively. We can see that the price paid for the adaptivity is very small: The rates of weakly adaptive regret differ from those of static regret only by logarithmic factors.


A major limitation of weakly adaptive regret is that it does not respect short intervals well. Taking convex functions as an example, the O(√(T log^3 T)) and O(√(T log T)) bounds are meaningless for intervals of length O(√(T)). To overcome this limitation, <cit.> proposed the strongly adaptive regret  (T,τ) which takes the length of the interval τ as a parameter, as indicated in (<ref>). From the definitions, we have (T,τ) ≤(T), but it does not mean  the notation of weakly adaptive regret is stronger, because an upper bound for (T) could be very loose for (T,τ) when τ is small.


If the strongly adaptive regret is small for all τ <T, we can guarantee the learner has a small regret over any interval of any length. In particular, <cit.> introduced the following definition.
 
Let R(τ) be the minimax static regret bound of the learning problem over τ periods. An algorithm is strongly adaptive, if

    (T,τ)=O((log T) · R(τ)),  ∀τ.


It is easy to verify that the meta-algorithms of <cit.> are strongly adaptive for exponentially concave functions,[That is because (i) (T,τ) ≤(T), and (ii) there is a (log T) factor in the definition of strong adaptivity. ] but not for convex functions. Thus, <cit.> developed a new meta-algorithm that satisfies (T,τ)=O( √(τ)log T ) for convex functions, and thus is strongly adaptive. The algorithm is also efficient and the computational complexity per iteration is O(log T). Later, the strongly adaptive regret of convex functions was improved to O( √(τlog T) ) by <cit.>, and the computational complexity remains O(log T) per iteration. All the previously mentioned algorithms for minimizing adaptive regret need to query the gradient of the loss function at least O(log t) times in the t-th iteration. In a recent study, <cit.> demonstrate that the number of gradient evaluations per iteration can be reduced to 1 by introducing the surrogate loss.



 §.§ Dynamic Regret
 
In a seminal work, <cit.> proposed to use the path-length defined as

    (_̆1, …, _̆T)=∑_t=2^T _̆t - _̆t-1_2

to upper bound the dynamic regret, where _̆1, …, _̆T ∈Ω is a comparator sequence. Specifically, <cit.> proved that for any sequence of convex functions, the dynamic regret of online gradient descent can be upper bounded by O(√(T)(_̆1, …, _̆T)). Another regularity of the comparator sequence, which is similar to the path-length, is defined as

    '(_̆1, …, _̆T)=∑_t=2^T _̆t - Φ_t (_̆t-1)_2

where Φ_t (·) is a dynamic model that predicts a reference point for the t-th round.  <cit.> developed a novel algorithm named dynamic mirror descent and proved that its dynamic regret is on the order of √(T)'(_̆1, …, _̆T). The advantage of '(_̆1, …, _̆T)  is that when the comparator sequence follows the dynamical model closely, it can be much smaller than the path-length (_̆1, …, _̆T).

Let _t^* ∈_∈Ω f_t() be a minimizer of f_t(·). For any sequence of _̆1, …, _̆T ∈Ω, we have

    (_̆1,…,_̆T) =∑_t=1^T f_t(_t)  - ∑_t=1^T f_t(_̆t) 
    ≤   (_1^*,…,_T^*) = ∑_t=1^T f_t(_t)  - ∑_t=1^T min_∈Ω f_t().

Thus, (_1^*,…,_T^*) can be treated as the worst case of the dynamic regret, and there are many works that were devoted to minimizing (_1^*,…,_T^*) <cit.>.

When a prior knowledge of (_1^*, …, _T^*) is available, (_1^*,…,_T^*) can be upper bounded by O(√(T (_1^*, …, _T^*))) <cit.>. If all the functions are strongly convex and smooth, the upper bound can be improved to O((_1^*, …, _T^*)) <cit.>. The O((_1^*, …, _T^*)) rate is also achievable when all the functions are convex and smooth, and all the minimizers _t^*'s lie in the interior of Ω <cit.>. In a recent study, <cit.> introduced a new regularity—squared path-length

    (_1^*, …, _T^*)=∑_t=2^T _t^* - _t-1^*_2^2

which could be much smaller than the path-length (_1^*, …, _T^*) when the difference between successive  minimizers is small. <cit.> developed a novel algorithm named online multiple gradient descent, and proved that (_1^*,…,_T^*) is on the order of min((_1^*, …, _T^*),(_1^*, …, _T^*)) for (semi-) strongly convex and smooth functions.




  
Discussions Although closely related, adaptive regret and dynamic regret are studied independently and there are few discussions of their relationships. In the literature, dynamic regret is also referred to as tracking regret or shifting regret <cit.>. In the setting of “prediction with expert advice”, <cit.> have shown that the tracking regret can be derived from the adaptive regret.  In the setting of “online linear optimization in the simplex”, <cit.> introduced a generalized notion of shifting regret which unifies  adaptive regret and shifting regret. Different from previous work, this paper considers the  setting of online convex optimization, and illustrates that the dynamic regret can be upper bounded by the adaptive regret and the functional variation.


§ A UNIFIED ADAPTIVE ALGORITHM
 
In this section, we introduce a unified approach for minimizing the adaptive regret of exponentially concave functions, as well as strongly convex functions.



 §.§ Motivation

We first provide the definition of exponentially concave (abbr. exp-concave) functions  <cit.>.
  A function f(·): Ω↦ is α-exp-concave if exp(-α f(·)) is concave over Ω.


For exp-concave functions, <cit.> have developed two meta-algorithms that take the online Newton step as its subroutine, and proved the following properties.

  
  * The inefficient one has O(T) computational complexity per iteration, and its adaptive regret is O(d log T).
  
  * The efficient one has O(log T) computational complexity per iteration, and its adaptive regret is O(d log^2 T).

As can be seen, there is a tradeoff between the computational complexity and the adaptive regret: A lighter computation incurs a looser bound and a tighter bound requires a  higher computation.  Our goal is to develop  a unified approach, that allows us to trade effectiveness for efficiency explicitly.


 §.§ Improved Following the Leading History (IFLH)

Let E be an online learning algorithm that is designed to minimize the static regret of exp-concave functions or strongly convex functions, e.g.,  online Newton step <cit.> or online gradient descent <cit.>. Similar to the approach of following the leading history (FLH) <cit.>, at any time t, we will instantiate an expert by applying the online learning algorithm E to the sequence of loss functions f_t,f_t+1,…, and utilize the strategy of learning from expert advice to combine solutions of different experts <cit.>. Our method is named as improved following the leading history (IFLH), and is summarized in Algorithm <ref>.

Let E^t be the expert that starts to work at time t. To control the computational complexity, we will associate an ending time e^t for each E^t.  The expert E^t is alive during the period [t, e^t-1]. In each round t, we maintain a working set of experts _t, which contains all the alive experts, and assign a probability p_t^j for each E^j ∈ S_t. In Steps 6 and 7, we remove all the experts whose ending times are no larger than t. Since the number of alive experts has changed, we need to update the probability assigned to them, which is performed in Steps 12 to 14. In Steps 15 and 16, we add a new expert E^t to _t, calculate its ending time according to Definition <ref> introduced below, and set p_t^t = 1/t. It is easy to verify ∑_E^j ∈_t p_t^j=1. Let _t^j be the output of E^j at the t-th round, where t ≥ j. In Step 17, we submit the weighted average of _t^j with coefficient p_t^j as the output _t, and suffer the loss f_t(_t). From Steps 18 to 25, we use the exponential weighting scheme to update the weight for each expert E^j based on its loss f_t(_t^j). In Step 21, we pass the loss function to all the alive experts such that they can update their predictions for the next round.


The difference between our IFLH and the original FLH is how to decide the ending time e^t of  expert E^t. In this paper, we propose the following base-K ending time.
[Base-K Ending Time]  Let K be an integer, and the representation of t in the base-K number system as

    t= ∑_τ≥ 0β_τ K^τ

where 0 ≤β_τ <K, for all τ≥ 0. Let k be the smallest integer such that β_k > 0, i.e., k = min{τ:β_τ > 0}. Then, the base-K ending time of t is defined as

    _K(t)=∑_τ≥ k+1β_τ K^τ + K^k+1.

In other words, the ending time is the number represented by the new sequence obtained by setting the first nonzero element in the sequence β_0,β_1,… to be 0 and adding 1 to the element after it.

 Let's take the decimal system as an example (i.e., K=10). Then,
 
    E_10(1)=E_10(2)=⋯ =E_10(9)=10,
       E_10(11)=E_10(12)=⋯=E_10(19)=20,
       E_10(10)=E_10(20)=⋯=E_10(90)=100.





 §.§ Theoretical Guarantees

When the base-K ending time is used in Algorithm <ref>, we have the following properties.
 
Suppose we use the base-K ending time in Algorithm <ref>.


  * For any t ≥ 1, we have

    |_t| ≤(⌊log_K t ⌋+1 ) (K-1)=O( K log t/log K).


  * For any interval I = [r, s] ⊆ [T], we can always find m segments I_j = [t_j, e^t_j-1],  j ∈ [m]
with m ≤⌈log_K (s-r+1)⌉ +1, such that t_1=r,  e^t_j=t_j+1,   j ∈ [m-1],  and  e^t_m > s.


The first part of Lemma <ref> implies that the size of _t is O(K log t/log K). An example of _t in the decimal system is given below.
 
    _486={   481,  482,  …,  486, 
       410,  420,  …,  480,
       100,  200,  …,  400
     } .

The second part of Lemma <ref> implies that for any interval I=[r, s], we can find O(log s/log K) experts such that their survival periods cover I. Again, we present an example in the decimal system: The interval [111, 832] can be covered by

    [111, 119],  [120, 199],  and  [200, 999]

which are the survival periods of experts E^111, E^120, and E^200,  respectively. Recall that E_10(111)=120, E_10(120)=200, and E_10(200)=1000.

We note that a similar strategy for deciding the ending time was proposed by <cit.> in the study of “prediction with expert advice”. The main difference is that their strategy  is built upon base-2 number system and introduces an additional parameter g to compromise between the computational complexity and the regret, in contrast our method relies on base-K number system and uses K to control the tradeoff. Lemma 2 of <cit.> indicates an O(g log t ) bound on the number of alive experts, which is worse than our O(K log t/log K) bound by a logarithmic factor.


To present adaptive regret bounds, we introduce the following common assumption.
 Both the gradient and the domain are bounded.


  * The gradients of all the online functions are bounded by G, i.e., max_∈Ω∇ f_t()≤ G for all f_t.

  * The diameter of the domain Ω is bounded by B, i.e., max_, ' ∈Ω -'≤ B.


Based on Lemma <ref>, we have the following theorem regarding the adaptive regret of exp-concave functions.
  Suppose Assumption <ref> holds, Ω⊂^d, and all the functions are α-exp-concave. If  online Newton step is used as the subroutine in Algorithm <ref>, we have

    ∑_t=r^s f_t(_t) - min_∈Ω∑_t=r^s f_t()≤((5d+1) m + 2/α + 5d mGB ) log T

where [r,s] ⊆ [T] and m ≤⌈log_K (s-r+1)⌉ +1. Thus,

    (T,τ)≤((5d+1) m̅ + 2/α + 5d m̅ GB ) log T = O( d log^2 T /log K)

where m̅=⌈log_K τ⌉ +1.

From Lemma <ref> and Theorem <ref>, we observe that the adaptive regret is a decreasing function of K, while the computational cost is an increasing function of K. Thus, we can control the tradeoff by tuning the value of K.
Specifically, Lemma <ref> indicates the proposed algorithm has

    (⌊log_K T ⌋+1 ) (K-1)=O( K log T/log K)

computational complexity per iteration. On the other hand, Theorem <ref> implies that for α-exp-concave functions that satisfy Assumption <ref>, the strongly adaptive regret of Algorithm <ref> is
 
    ((5d+1) m̅ + 2/α + 5d m̅ GB ) log T = O(  d log^2 T/log K)

where d is the dimensionality and m̅= ⌈log_K (τ)⌉ +1.

We list several choices of K and the resulting theoretical guarantees in Table <ref>, and have the following observations.


  * When K=2, we recover the guarantee of the  efficient algorithm of <cit.>, and when K=T, we obtain the inefficient one.
  
  * By setting K=⌈ T^1/γ⌉ where γ>1 is a small constant, such as 10, the strongly adaptive regret can be viewed as O(d log T), and at the same time,  the computational complexity is also very low for a large range of T. 







Next, we consider strongly convex functions.
 A function f(·): Ω↦ is λ-strongly convex if

    f() ≥ f() + ⟨∇ f(),  -⟩ + λ/2 -_2^2,   ∀, ∈Ω.


It is easy to verify that strongly convex functions with bounded gradients are also exp-concave <cit.>.
  Suppose f(·): Ω↦ is λ-strongly convex and ∇ f()≤ G for all ∈Ω. Then, f(·) is λ/G^2-exp-concave.

According to the above lemma, we still use Algorithm <ref> as the meta-algorithm, but choose online gradient descent as the subroutine. In this way, the adaptive regret does not depend on the dimensionality d.

  Suppose Assumption <ref> holds, and  all the functions are λ-strongly convex. If online gradient descent is used as the subroutine in Algorithm <ref>, we have

    ∑_t=r^s f_t(_t) - min_∈Ω∑_t=r^s f_t()
     ≤G^2/2λ(m+ (3 m +4)  log T )

where [r,s] ⊆ [T] and m ≤⌈log_K (s-r+1)⌉ +1. Thus

    (T,τ)≤G^2/2λ(m̅+ (3m̅ +4)  log T )= O( log^2 T /log K)

where m̅=⌈log_K τ⌉ +1.




§ FROM ADAPTIVE TO DYNAMIC

In this section, we first introduce a general theorem that bounds the dynamic regret by the adaptive regret, and then derive specific regret bounds  for convex functions, exponentially concave functions, and strongly convex functions.



 §.§ Adaptive-to-Dynamic Conversion

Let _1=[s_1, q_1], _2 = [s_2, q_2], …, _k=[s_k, q_k] be a partition of [1,T]. That is, they are successive intervals such that

    s_1=1,  q_i +1 = s_i+1,    i ∈ [k-1],  and  q_k=T.

Define the local functional variation of the i-th interval as

    V_T(i) = ∑_t=s_i+1^q_imax_∈Ω |f_t() - f_t-1()|

and it is obvious that ∑_i=1^k V_T(i) ≤ V_T.[Note that in certain cases, the sum of local functional variation ∑_i=1^k V_T(i) can be much smaller than the total functional variation V_T. For example, when the sequence of functions only changes k times,  we can construct the intervals based on the changing rounds such that ∑_i=1^k V_T(i)=0.]
Then, we have the following theorem for bounding the dynamic regret in terms of the strongly adaptive regret and the functional variation.
  Let _t^* ∈_∈Ω f_t().  For all integer k ∈ [T], we have

    (_1^*,…,_T^*) ≤min__1,…,_k∑_i=1^k ( (T,|_i|) + 2 |_i| · V_T(i) )

where the minimization is taken over any sequence of intervals that satisfy (<ref>).

The above theorem is analogous to Proposition 2 of <cit.>, which provides an upper bound for a special choice of the interval sequence. The main difference is that there is a minimization operation in our bound, which allows us to get rid of the issue of parameter selection. For a specific type of problems, we can plug in the corresponding upper bound of strongly adaptive regret, and then choose any sequence of intervals to obtain a concrete upper bound. In particular, the choice of the intervals may depend on the (possibly unknown) functional variation.





 §.§ Convex Functions
 
For convex functions, we choose the meta-algorithm of <cit.> and take the online gradient descent as its subroutine. The following theorem regarding the adaptive regret can be obtained from that paper.
   Under Assumption <ref>, the meta-algorithm of <cit.> is strongly adaptive with

    (T,τ) ≤(12 BG/√(2)-1 +8 √(7 log T + 5)) √(τ)  = O(√(τlog T)  ).


From Theorems <ref> and <ref>, we derive the following bound for the dynamic regret.
  Under Assumption <ref>, the meta-algorithm of <cit.>  satisfies

    (_1^*,…,_T^*)≤   max{     (c +9 √(7 log T + 5))  √(T)
       (c +8 √(5) )  T^2/3 V_T^1/3/log^1/6 T    + 24 T^2/3 V_T^1/3log^1/3 T
    .
    
    =     O ( max{√(T log T) , T^2/3 V_T^1/3log^1/3 T  })

where c=12 BG/(√(2)-1).

According to Theorem 2 of <cit.>, we know that the minimax dynamic regret of convex functions is O(T^2/3 V_T^1/3). Thus, our upper bound is minimax optimal up to a polylogarithmic factor. Although the restarted online gradient descent  of  <cit.> achieves a dynamic regret of O(T^2/3V_T^1/3), it requires to know an upper bound of the functional variation V_T. In contrast, the meta-algorithm of  <cit.> does not need any prior knowledge of V_T. We note that the meta-algorithm of  <cit.> can also be used here, and its dynamic regret  is on the order of max{√(T)log T, T^2/3 V_T^1/3log^2/3 T  }.


 §.§ Exponentially Concave Functions

We proceed to consider exp-concave functions, defined in Definition <ref>. Exponential concavity is stronger than convexity but weaker than strong convexity. It can be used to model many popular losses used in machine learning, such as the square loss in regression, logistic loss in classification and negative logarithm loss in portfolio management <cit.>.

For exp-concave functions, we choose Algorithm <ref> in this paper, and take the online Newton step as its subroutine. Based on Theorems <ref> and <ref>, we derive the dynamic regret of the proposed algorithm.
  Let K=⌈ T^1/γ⌉, where γ>1 is a small constant. Suppose Assumption <ref> holds, Ω⊂^d, and all the functions are α-exp-concave. Algorithm <ref>, with online Newton step as its subroutine, is strongly adaptive with

    (T,τ)≤   ((5d+1) (γ+1) + 2/α + 5d (γ+1) GB ) log T
    
    =   O(γ d log T)=O( d log T)

and its dynamic regret satisfies

    (_1^*,…,_T^*)
    ≤   ((5d+1) (γ+1) + 2/α + 5d (γ+1) GB +2)  max{log T, √(T V_T log T)}
    
    =     O (d ·max{log T, √(T V_T log T)}).


To the best of our knowledge, this is the first dynamic regret that exploits exponential concavity. Furthermore, according to the minimax dynamic regret of strongly convex functions <cit.>, our upper bound is  minimax optimal, up to a polylogarithmic factor.


 §.§ Strongly Convex Functions
 
Finally, we study strongly convex functions. According to Lemma <ref>, we know that strongly convex functions with bounded gradients are also exp-concave. Thus, Corollary <ref> can be directly applied to strongly convex functions, and yields a dynamic regret of O(d √(T V_T log T)).  However, the upper bound depends on the dimensionality d. To address this limitation, we use online gradient descent as the subroutine in Algorithm <ref>.

From Theorems <ref> and <ref>, we have the following theorem, in which both the adaptive and dynamic regrets are independent from d.
  Let K=⌈ T^1/γ⌉, where γ>1 is a small constant. Suppose Assumption <ref> holds, and  all the functions are λ-strongly convex.  Algorithm <ref>, with online gradient descent as its subroutine, is strongly adaptive with

    (T,τ) ≤G^2/2λ(γ+1+ (3 γ+7)  log T  )= O(γlog T)=O( log T)

and its dynamic regret satisfies

    (_1^*,…,_T^*)≤   max{   γ G^2 /λ + (5 γ G^2/λ +2 ) log T 
       γ G^2 /λ√(T V_T/log T)+ (5 γ G^2/λ +2 )√(T V_T log T).
    
    =     O ( max{log T, √(T V_T log T)}).


According to Theorem 4 of <cit.>, the minimax dynamic regret of strongly convex functions is O(√(T V_T)), which implies our upper bound is almost minimax optimal. By comparison, the restarted online gradient descent  of  <cit.> has a dynamic regret of O(log T √(T V_T)), but it requires to know an upper bound of V_T.



§ ANALYSIS

We here present the proof of main theorems.




 §.§ Proof of Theorem <ref>

From the second part of Lemma <ref>, we know that there exist m segments

    I_j = [t_j, e^t_j-1],  j ∈ [m]

with m ≤⌈log_K (s-r+1)⌉ +1, such that

    t_1=r,  e^t_j=t_j+1,   j ∈ [m-1],  and  e^t_m > s.

Furthermore, the expert E^t_j is alive during the period [t_j, e^t_j-1].

Using Claim 3.1 of <cit.>, we have

    ∑_t = t_j^e^t_j-1 f_t(_t) - f_t(^t_j_t) ≤1/α(log t_j + 2∑_t = t_j + 1^e^t_j-11/t),  ∀ j ∈ [m-1]

where ^t_j_t_j, …, ^t_j_e^t_j-1 is the sequence of solutions generated by the expert E^t_j. Similarly, for the last segment, we have

    ∑_t = t_m^s f_t(_t) - f_t(^t_m_t) ≤1/α(log  t_m + 2∑_t =  t_m + 1^s1/t).


By adding things together, we have

    ∑_j=1^m-1(∑_t = t_j^e^t_j-1 f_t(_t) - f_t(^t_j_t) )  + ∑_t = t_m^s f_t(_t) - f_t(^t_m_t)  
    ≤   1/α∑_j=1^m log t_j  + 2/α∑_t=r+1^s 1/t≤m + 2/αlog T .

According to the property of online Newton step <cit.>, we have, for any ∈Ω,

    ∑_t = t_j^e^t_j-1 f_t(^t_j_t) - f_t() ≤ 5d (1/α +GB )log T,  ∀ j ∈ [m-1]

and

    ∑_t = t_m^s  f_t(^t_m_t) - f_t() ≤ 5d (1/α +GB )log T.


Combining (<ref>), (<ref>), and (<ref>), we have,

    ∑_t=r^s f_t(_t) -  ∑_t=r^s f_t() ≤((5d+1) m + 2/α + 5d mGB ) log T

for any ∈Ω.



 §.§ Proof of Theorem <ref>

Lemma <ref> implies that all the λ-strongly convex functions are also λ/G^2-exp-concave. As a result, we can reuse the proof of Theorem <ref>. Specifically, (<ref>) with α=λ/G^2 becomes

    ∑_j=1^m-1(∑_t = t_j^e^t_j-1 f_t(_t) - f_t(^t_j_t) )  + ∑_t = t_m^s f_t(_t) - f_t(^t_m_t)    ≤(m + 2)G^2/λlog T .

According to the property of online gradient descent <cit.>, we have, for any ∈Ω,

    ∑_t = t_j^e^t_j-1 f_t(^t_j_t) - f_t() ≤G^2/2λ (1+log T),  ∀ j ∈ [m-1]

and

    ∑_t = t_m^s  f_t(^t_m_t) - f_t() ≤G^2/2λ (1+log T).

Combining (<ref>), (<ref>), and (<ref>), we have,

    ∑_t=r^s f_t(_t) -  ∑_t=r^s f_t() ≤G^2/2λ(m+ (3 m +4)  log T )

for any ∈Ω.




 §.§ Proof of Theorem <ref>

First, we upper bound the dynamic regret in the following way

    (_1^*,…,_T^*) 
    
    =    ∑_i=1^k (∑_t=s_i^q_i f_t(_t)  - ∑_t=s_i^q_imin_∈Ω f_t() )
    
    =    ∑_i=1^k ( ∑_t=s_i^q_i f_t(_t) - min_∈Ω∑_t=s_i^q_i f_t()_:=a_i +min_∈Ω∑_t=s_i^q_i f_t()- ∑_t=s_i^q_imin_∈Ω f_t()_:=b_i).


From the definition of strongly adaptive regret, we can upper bound a_i by

    ∑_t=s_i^q_i f_t(_t) - min_∈Ω∑_t=s_i^q_i f_t() ≤(T,|_i|).

To upper bound b_i, we follow the analysis of Proposition 2 of <cit.>:

    min_∈Ω∑_t=s_i^q_i f_t()- ∑_t=s_i^q_imin_∈Ω f_t()= min_∈Ω∑_t=s_i^q_i f_t()- ∑_t=s_i^q_i  f_t(_t^*) 
    ≤   ∑_t=s_i^q_i f_t(_s_i^*)- ∑_t=s_i^q_i  f_t(_t^*) ≤ |_i| ·max_t ∈ [s_i,q_i]( f_t(_s_i^*)- f_t(_t^*) ).

Furthermore, for any t ∈ [s_i,q_i], we have

    f_t(_s_i^*)- f_t(_t^*)  =  f_t(_s_i^*)- f_s_i(_s_i^*) + f_s_i(_s_i^*)  -  f_t(_t^*) 
    ≤    f_t(_s_i^*)- f_s_i(_s_i^*) + f_s_i(_t^*)  -  f_t(_t^*) ≤  2 V_T(i).

Combining (<ref>) with (<ref>), we have

    min_∈Ω∑_t=s_i^q_i f_t()- ∑_t=s_i^q_imin_∈Ω f_t()  ≤ 2  |_i| · V_T(i).


Substituting the upper bounds of a_i and b_i into (<ref>), we arrive at

    (_1^*,…,_T^*)≤∑_i=1^k (  (T,|_i|)+ 2  |_i| · V_T(i) ).

Since the above inequality holds for any partition of [1,T], we can take minimization to get a tight bound.




 §.§ Proof of Corollary <ref>

To simplify the upper bound in Theorem <ref>, we restrict to intervals of the same length τ, and in this case k=T/τ. Then, we have

    (_1^*,…,_T^*) ≤   min_1 ≤τ≤ T∑_i=1^k ( (T,τ) + 2 τ  V_T(i) )
    
    =    min_1 ≤τ≤ T(  (T,τ) T/τ + 2 τ∑_i=1^k V_T(i) )
    ≤   min_1 ≤τ≤ T( (T,τ) T/τ + 2 τ V_T ).

Combining with Theorem <ref>, we have

    (_1^*,…,_T^*)≤min_1 ≤τ≤ T( (c +8 √(7 log T + 5))  T /√(τ) + 2 τ V_T ).

where c=12 BG/(√(2)-1).



In the following, we consider two cases. If V_T ≥√(log T/T), we choose

    τ = ( T √(log T)/V_T)^2/3≤ T

and have

    (_1^*,…,_T^*)  ≤   (c +8 √(7 log T + 5) )  T^2/3 V_T^1/3/log^1/6 T    + 2 T^2/3 V_T^1/3log^1/3 T
    ≤   (c +8 √(5) )  T^2/3 V_T^1/3/log^1/6 T    + (2+ 8√(7)) T^2/3 V_T^1/3log^1/3 T.

Otherwise, we choose  τ=T, and have

    (_1^*,…,_T^*)  ≤   (c +8 √(7 log T + 5))  √(T)  + 2 T V_T 
    ≤    (c +8 √(7 log T + 5))  √(T)  + 2 T √(log T/T)
    ≤    (c +9 √(7 log T + 5))  √(T).


In summary, we have

    (_1^*,…,_T^*)≤   max{     (c +9 √(7 log T + 5))  √(T)
       (c +8 √(5) )  T^2/3 V_T^1/3/log^1/6 T    + 24 T^2/3 V_T^1/3log^1/3 T
    .
    
    =     O ( max{√(T log T) , T^2/3 V_T^1/3log^1/3 T  }).




 §.§ Proof of Corollary <ref>

The first part of Corollary <ref> is a direct consequence of Theorem <ref> by setting K=⌈ T^1/γ⌉.

Now, we prove the second part. Following similar analysis of Corollary <ref>, we have

    (_1^*,…,_T^*) ≤min_1 ≤τ≤ T{((5d+1) (γ+1) + 2/α + 5d (γ+1) GB )  T log T /τ + 2 τ V_T }.

Then, we consider two cases. If V_T ≥log T/T, we choose

    τ = √(T log T /V_T)≤ T

and have

    (_1^*,…,_T^*)  ≤((5d+1) (γ+1) + 2/α + 5d (γ+1) GB +2)√(T V_T log T) .

Otherwise, we choose  τ=T, and have

    (_1^*,…,_T^*) ≤   ((5d+1) (γ+1) + 2/α + 5d (γ+1) GB )  log T + 2 T V_T 
    ≤   ((5d+1) (γ+1) + 2/α + 5d (γ+1) GB )  log T + 2 T log T/T
    
    =    ((5d+1) (γ+1) + 2/α + 5d (γ+1) GB +2) log T .


In summary, we have

    (_1^*,…,_T^*)
    ≤   ((5d+1) (γ+1) + 2/α + 5d (γ+1) GB +2)
      max{log T, √(T V_T log T)}
    
    =     O (d ·max{log T, √(T V_T log T)}).




 §.§ Proof of Corollary <ref>

The first part of Corollary <ref> is a direct consequence of Theorem <ref> by setting K=⌈ T^1/γ⌉.

The proof of the second part is similar to that of Corollary <ref>. First, we have

    (_1^*,…,_T^*) ≤   min_1 ≤τ≤ T{G^2/2λ(γ+1+ (3 γ+7)  log T ) T/τ + 2 τ V_T }
    ≤   min_1 ≤τ≤ T{( γ+ 5 γlog T )G^2 T/λτ + 2 τ V_T }

where the last inequality is due to the condition γ >1.

Then, we consider two cases. If V_T ≥log T/T, we choose

    τ = √(T log T /V_T)≤ T

and have

    (_1^*,…,_T^*)  ≤   γ G^2 /λ√(T V_T/log T)+ 5 γ G^2/λ√(T V_T log T) +  2 √(T V_T log T)
    
    =   γ G^2 /λ√(T V_T/log T)+ (5 γ G^2/λ +2 )√(T V_T log T)  .

Otherwise, we choose  τ=T, and have

    (_1^*,…,_T^*) ≤   ( γ+ 5 γlog T )G^2/λ + 2 T V_T 
    ≤   ( γ+ 5 γlog T )G^2/λ +2 T log T/T
    
    =   γ G^2 /λ + (5 γ G^2/λ +2 ) log T.


In summary, we have

    (_1^*,…,_T^*)
    ≤   max{   γ G^2 /λ + (5 γ G^2/λ +2 ) log T 
       γ G^2 /λ√(T V_T/log T)+ (5 γ G^2/λ +2 )√(T V_T log T).
    
    =     O ( max{log T, √(T V_T log T)}).





§ CONCLUSIONS AND FUTURE WORK

In this paper, we demonstrate that the dynamic regret can be upper bounded by the adaptive regret and the functional variation, which implies strongly adaptive algorithms are automatically equipped with tight dynamic regret bounds. As a result, we are able to derive dynamic regret bounds for convex functions, exp-concave functions, and strongly convex functions. Moreover, we provide a unified approach for minimizing the adaptive regret of exp-concave functions, as well as strongly convex functions.

The adaptive-to-dynamic conversion  leads to a series of dynamic regret bounds in terms of the functional variation.  As we mentioned before, dynamic regret can also be upper bounded by other regularities such as the path-length. It is interesting to investigate whether those kinds of upper bounds can also be established for strongly adaptive algorithms.



§ PROOF OF LEMMA <REF>

We first prove the first part of Lemma <ref>.  Let k= ⌊log_K t ⌋. Then, integer t can be represented in the base-K number system as

    t = ∑_j=0^k β_j K^j .

From the definition of base-K ending time, integers that are no larger than t and alive at t are

    {   1*K^0+∑_j=1^k β_j K^j,   2*K^0+ ∑_j=1^k β_j K^j,  …,  β_0*K^0 + ∑_j=1^k β_j K^j 
       1*K^1+∑_j=2^k β_j K^j,   2*K^1+ ∑_j=2^k β_j K^j,  …,  β_1*K^1 + ∑_j=2^k β_j K^j 
       …
       1*K^k-1+β_k K^k,   1*K^k-1+  β_k K^k,  …,  β_k-1*K^k-1 +β_k K^k 
       1 *K^k,   2 * K^k,  …,  β_k K^k 
    }.

The total number of alive integers are upper bounded by

    ∑_i=0^k β_i ≤ (k+1) (K-1)= (⌊log_K t ⌋+1) (K-1).




We proceed to prove the second part of Lemma <ref>.  Let k= ⌊log_K r ⌋, and the representation of r in the base-K number system be

    r= ∑_j=0^k β_j K^j.

We generate a sequence of segments as

    I_1    = [t_1, e^t_1-1] =[∑_j=0^k β_j K^j, (β_1+1) K^1+∑_j=2^k β_j K^j - 1], 
    
     I_2    = [t_2, e^t_2-1] = [(β_1+1) K^1+∑_j=2^k β_j K^j, (β_2+1) K^2+∑_j=3^k β_j K^j - 1], 
    
      I_3    = [t_3, e^t_3-1] = [(β_2+1) K^2+∑_j=3^k β_j K^j, (β_3+1) K^3+∑_j=4^k β_j K^j - 1], 
       …
    
     I_k    = [t_k, e^t_k-1] = [(β_k-1+1)K^k-1 +β_k K^k, (β_k+1) K^k - 1], 
    
     I_k+1    = [t_k+1, e^t_k+1-1] = [(β_k+1) K^k, K^k+1-1], 
    
     I_k+2    = [t_k+2, e^t_k+2-1] = [K^k+1, K^k+2-1], 
       …

until s is covered. It is easy to verify that

    t_m+1 > t_m + K^m-1 -1.

Thus, s will be covered by the first m intervals as long as

    t_m + K^m-1 -1  ≥ s.

A sufficient condition is

    r+ K^m-1 -1  ≥ s

which is satisfied when

    m=⌈log_K (s-r+1)⌉ +1.




§ PROOF OF LEMMA <REF>

The gradient of exp(-α f()) is

    ∇exp(-α f()) =  exp(-α f())  -α∇ f() = -αexp(-α f()) ∇ f().

and the Hessian is

    ∇^2 exp(-α f()) =    -αexp(-α f()) -α∇ f() ∇^⊤ f() -αexp(-α f()) ∇^2 f() 
    
    =    αexp(-α f()) (α∇ f() ∇^⊤ f()  -  ∇^2 f()  ).

Thus, f(·) is α-exp-concave if

    α∇ f() ∇^⊤ f()  ≼∇^2 f().

We complete the proof by noticing

    λ/G^2∇ f() ∇^⊤ f() ≼λ I ≼∇^2 f().




§ PROOF OF THEOREM <REF>

As pointed out by <cit.>, the static regret of online gradient descent <cit.> over any interval of length τ is upper bounded by 3BG√(τ). Combining this fact with Theorem 2 of <cit.>, we get Theorem <ref> in this paper.


