A Drifting-Games Analysis for Online Learning and Applications to Boosting

A Drifting-Games Analysis for Online Learning and Applications to Boosting

Haipeng Luo
Department of Computer Science
Princeton University
Princeton, NJ 08540haipengl@cs.princeton.edu
and Robert E. SchapireR. Schapire is currently at Microsoft Research in New York City.
Department of Computer Science
Princeton University
Princeton, NJ 08540schapire@cs.princeton.edu

Abstract

We provide a general mechanism to design online learning algorithms based on a minimax analysis within a drifting-games framework. Different online learning settings (Hedge, multi-armed bandit problems and online convex optimization) are studied by converting into various kinds of drifting games. The original minimax analysis for drifting games is then used and generalized by applying a series of relaxations, starting from choosing a convex surrogate of the 0-1 loss function. With different choices of surrogates, we not only recover existing algorithms, but also propose new algorithms that are totally parameter-free and enjoy other useful properties. Moreover, our drifting-games framework naturally allows us to study high probability bounds without resorting to any concentration results, and also a generalized notion of regret that measures how good the algorithm is compared to all but the top small fraction of candidates. Finally, we translate our new Hedge algorithm into a new adaptive boosting algorithm that is computationally faster as shown in experiments, since it ignores a large number of examples on each round.

In this paper, we study online learning problems within a drifting-games framework, with the aim of developing a general methodology for designing learning algorithms based on a minimax analysis.

To solve an online learning problem, it is natural to consider game-theoretically optimal algorithms which find the best solution even in worst-case scenarios. This is possible for some special cases ([?]) but difficult in general. On the other hand, many other efficient algorithms with optimal regret rate (but not exactly minimax optimal) have been proposed for different learning settings (such as the exponential weights algorithm [?], and follow the perturbed leader [?]). However, it is not always clear how to come up with these algorithms. Recent work by Rakhlin et al. [?] built a bridge between these two classes of methods by showing that many existing algorithms can indeed be derived from a minimax analysis followed by a series of relaxations.

In this paper, we provide a parallel way to design learning algorithms by first converting online learning problems into variants of drifting games, and then applying a minimax analysis and relaxations. Drifting games[?] (reviewed in Section 2) generalize Freund’s “majority-vote game” [?] and subsume some well-studied boosting and online learning settings. A nearly minimax optimal algorithm is proposed in [?]. It turns out the connections between drifting games and online learning go far beyond what has been discussed previously. To show that, we consider variants of drifting games that capture different popular online learning problems. We then generalize the minimax analysis in [?] based on one key idea: relax a 0-1 loss function by a convex surrogate. Although this idea has been applied widely elsewhere in machine learning, we use it here in a new way to obtain a very general methodology for designing and analyzing online learning algorithms. Using this general idea, we not only recover existing algorithms, but also design new ones with special useful properties. A somewhat surprising result is that our new algorithms are totally parameter-free, which is usually not the case for algorithms derived from a minimax analysis. Moreover, a generalized notion of regret (ϵ-regret, defined in Section 3) that measures how good the algorithm is compared to all but the top ϵ fraction of candidates arises naturally in our drifting-games framework. Below we summarize our results for a range of learning settings.

Hedge Settings:

(Section 3) The Hedge problem [?] investigates how to cleverly bet across a set of actions. We show an algorithmic equivalence between this problem and a simple drifting game (DGv1). We then show how to relax the original minimax analysis step by step to reach a general recipe for designing Hedge algorithms (Algorithm ?). Three examples of appropriate convex surrogates of the 0-1 loss function are then discussed, leading to the well-known exponential weights algorithm and two other new ones, one of which (NormalHedge.DT in Section 3.3) bears some similarities with the NormalHedge algorithm [?] and enjoys a similar ϵ-regret bound simultaneously for all ϵ and horizons. However, our regret bounds do not depend on the number of actions, and thus can be applied even when there are infinitely many actions. Our analysis is also arguably simpler and more intuitive than the one in [?] and easy to be generalized to more general settings. Moreover, our algorithm is more computationally efficient since it does not require a numerical searching step as in NormalHedge. Finally, we also derive high probability bounds for the randomized Hedge setting as a simple side product of our framework without using any concentration results.

Multi-armed Bandit Problems:

(Section 4) The multi-armed bandit problem [?] is a classic example for learning with incomplete information where the learner can only obtain feedback for the actions taken. To capture this problem, we study a quite different drifting game (DGv2) where randomness and variance constraints are taken into account. Again the minimax analysis is generalized and the EXP3 algorithm [?] is recovered. Our results could be seen as a preliminary step to answer the open question [?] on exact minimax optimal algorithms for the multi-armed bandit problem.

Online Convex Optimization:

(Section 4) Based the theory of convex optimization, online convex optimization [?] has been the foundation of modern online learning theory. The corresponding drifting game formulation is a continuous space variant (DGv3). Fortunately, it turns out that all results from the Hedge setting are ready to be used here, recovering the continuous EXP algorithm [?] and also generalizing our new algorithms to this general setting. Besides the usual regret bounds, we also generalize the ϵ-regret, which, as far as we know, is the first time it has been explicitly studied. Again, we emphasize that our new algorithms are adaptive in ϵ and the horizon.

Boosting:

(Section 4) Realizing that every Hedge algorithm can be converted into a boosting algorithm ([?]), we propose a new boosting algorithm (NH-Boost.DT) by converting NormalHedge.DT. The adaptivity of NormalHedge.DT is then translated into training error and margin distribution bounds that previous analysis in [?] using nonadaptive algorithms does not show. Moreover, our new boosting algorithm ignores a great many examples on each round, which is an appealing property useful to speeding up the weak learning algorithm. This is confirmed by our experiments.

Related work

: Our analysis makes use of potential functions. Similar concepts have widely appeared in the literature [?], but unlike our work, they are not related to any minimax analysis and might be hard to interpret. The existence of parameter free Hedge algorithms for unknown number of actions was shown in [?], but no concrete algorithms were given there. Boosting algorithms that ignore some examples on each round were studied in [?], where a heuristic was used to ignore examples with small weights and no theoretical guarantee is provided.

We consider a simplified version of drifting games similar to the one described in [?] (also called chip games). This game proceeds through T rounds, and is played between a player and an adversary who controls N chips on the real line. The positions of these chips at the end of round t are denoted by st∈RN, with each coordinate st,i corresponding to the position of chip i. Initially, all chips are at position 0 so that s0=0. On every round t=1,…,T: the player first chooses a distribution pt over the chips, then the adversary decides the movements of the chips zt so that the new positions are updated as st=st−1+zt. Here, each zt,i has to be picked from a prespecified set B⊂R, and more importantly, satisfy the constraint pt⋅zt≥β≥0 for some fixed constant β.

At the end of the game, each chip is associated with a nonnegative loss defined by L(sT,i) for some nonincreasing function L mapping from the final position of the chip to R+. The goal of the player is to minimize the chips’ average loss 1N∑Ni=1L(sT,i) after T rounds. So intuitively, the player aims to “push” the chips to the right by assigning appropriate weights on them so that the adversary has to move them to the right by β in a weighted average sense on each round. This game captures many learning problems. For instance, binary classification via boosting can be translated into a drifting game by treating each training example as a chip (see [?] for details).

We regard a player’s strategy D as a function mapping from the history of the adversary’s decisions to a distribution that the player is going to play with, that is, pt=D(z1:t−1) where z1:t−1 stands for z1,…,zt−1. The player’s worst case loss using this algorithm is then denoted by LT(D). The minimax optimal loss of the game is computed by the following expression: minDLT(D)=minp1∈ΔNmaxz1∈Zp1⋯minpT∈ΔNmaxzT∈ZpT1N∑Ni=1L(∑Tt=1zt,i), where ΔN is the N dimensional simplex and Zp=BN∩{z:p⋅z≥β} is assumed to be compact. A strategy D∗ that realizes the minimum in minDLT(D) is called a minimax optimal strategy. A nearly optimal strategy and its analysis is originally given in [?], and a derivation by directly tackling the above minimax expression can be found in [?]. Specifically, a sequence of potential functions of a chip’s position is defined recursively as follows:

ΦT(s)=L(s),Φt−1(s)=minw∈R+maxz∈B(Φt(s+z)+w(z−β)).(1)

Let wt,i be the weight that realizes the minimum in the definition of Φt−1(st−1,i), that is, wt,i∈argminwmaxz(Φt(st−1,i+z)+w(z−β)). Then the player’s strategy is to set pt,i∝wt,i. The key property of this strategy is that it assures that the sum of the potentials over all the chips never increases, connecting the player’s final loss with the potential at time 0 as follows:

It has been shown in [?] that this upper bound on the loss is optimal in a very strong sense.

Moreover, in some cases the potential functions have nice closed forms and thus the algorithm can be efficiently implemented. For example, in the boosting setting, B is simply {−1,+1}, and one can verify Φt(s)=1+β2Φt+1(s+1)+1−β2Φt+1(s−1) and wt,i=12(Φt(st−1,i−1)−Φt(st−1,i+1)). With the loss function L(s) being 1{s≤0}, these can be further simplified and eventually give exactly the boost-by-majority algorithm [?].

The connection between drifting games and some specific settings of online learning has been noticed before ([?]). We aim to find deeper connections or even an equivalence between variants of drifting games and more general settings of online learning, and provide insights on designing learning algorithms through a minimax analysis. We start with a simple yet classic Hedge setting.

In the Hedge setting [?], a player tries to earn as much as possible (or lose as little as possible) by cleverly spreading a fixed amount of money to bet on a set of actions on each day. Formally, the game proceeds for T rounds, and on each round t=1,…,T: the player chooses a distribution pt over N actions, then the adversary decides the actions’ losses ℓt (i.e. action i incurs loss ℓt,i∈[0,1]) which are revealed to the player. The player suffers a weighted average loss pt⋅ℓt at the end of this round. The goal of the player is to minimize his “regret”, which is usually defined as the difference between his total loss and the loss of the best action. Here, we consider an even more general notion of regret studied in [?], which we call ϵ-regret. Suppose the actions are ordered according to their total losses after T rounds (i.e. ∑Tt=1ℓt,i) from smallest to largest, and let iϵ be the index of the action that is the ⌈Nϵ⌉-th element in the sorted list (0<ϵ≤1). Now, ϵ-regret is defined as RϵT(p1:T,ℓ1:T)=∑Tt=1pt⋅ℓt−∑Tt=1ℓt,iϵ. In other words, ϵ-regret measures the difference between the player’s loss and the loss of the ⌈Nϵ⌉-th best action (recovering the usual regret with ϵ≤1/N), and sublinear ϵ-regret implies that the player’s loss is almost as good as all but the top ϵ fraction of actions. Similarly, RϵT(H) denotes the worst case ϵ-regret for a specific algorithm H. For convenience, when ϵ≤0 or ϵ>1, we define ϵ-regret to be ∞ or −∞ respectively.

Next we discuss how Hedge is highly related to drifting games. Consider a variant of drifting games where B=[−1,1],β=0 and L(s)=1{s≤−R} for some constant R. Additionally, we impose an extra restriction on the adversary: |zt,i−zt,j|≤1 for all i and j. In other words, the difference between any two chips’ movements is at most 1. We denote this specific variant of drifting games by DGv1 (summarized in Appendix A) and a corresponding algorithm by DR to emphasize the dependence on R. The reductions in Algorithm ? and ? and Theorem ? show that DGv1 and the Hedge problem are algorithmically equivalent (note that both conversions are valid). The proof is straightforward and deferred to Appendix B. By Theorem ?, it is clear that the minimax optimal algorithm for one setting is also minimax optimal for the other under these conversions.

From now on we only focus on the direction of converting a drifting game algorithm into a Hedge algorithm. In order to derive a minimax Hedge algorithm, Theorem ? tells us it suffices to derive minimax DGv1 algorithms. Exact minimax analysis is usually difficult, and appropriate relaxations seem to be necessary. To make use of the existing analysis for standard drifting games, the first obvious relaxation is to drop the additional restriction in DGv1, that is, |zt,i−zt,j|≤1 for all i and j. Doing this will lead to the exact setting discussed in [?] where a near optimal strategy is proposed using the recipe in Eq. . It turns out that this relaxation is reasonable and does not give too much more power to the adversary. To see this, first recall that results from [?], written in our notation, state that minDRLT(DR)≤12T∑T−R2j=0(T+1j), which, by Hoeffding’s inequality, is upper bounded by 2exp(−(R+1)22(T+1)). Second, statement (2) in Theorem ? clearly remains valid if the input of Algorithm ? is a drifting game algorithm for this relaxed version of DGv1. Therefore, by setting ϵ>2exp(−(R+1)22(T+1)) and solving for R, we have RϵT(H)≤O(√Tln(1ϵ)), which is the known optimal regret rate for the Hedge problem, showing that we lose little due to this relaxation.

However, the algorithm proposed in [?] is not computationally efficient since the potential functions Φt(s) do not have closed forms. To get around this, we would want the minimax expression in Eq. to be easily solved, just like the case when B={−1,1}. It turns out that convexity would allow us to treat B=[−1,1] almost as B={−1,1}. Specifically, if each Φt(s) is a convex function of s, then due to the fact that the maximum of a convex function is always realized at the boundary of a compact region, we have

with w=(Φt(s−1)−Φt(s+1))/2 realizing the minimum. Since the 0-1 loss function L(s) is not convex, this motivates us to find a convex surrogate of L(s). Fortunately, relaxing the equality constraints in Eq. does not affect the key property of Eq. as we will show in the proof of Theorem ?. “Compiling out” the input of Algorithm ?, we thus have our general recipe (Algorithm ?) for designing Hedge algorithms with the following regret guarantee.

Proof. It suffices to show that Eq. holds so that the theorem follows by a direct application of statement (2) of Theorem ?. Let wt,i=(Φt(st−1,i−1)−Φt(st−1,i+1))/2. Then ∑iΦt(st,i)≤∑i(Φt(st−1,i+zt,i)+wt,izt,i) since pt,i∝wt,i and pt⋅zt≥0. On the other hand, by Eq. , we have Φt(st−1,i+zt,i)+wt,izt,i≤minw∈R+maxz∈[−1,1](Φt(st−1,i+z)+wz)=12(Φt(st−1,i−1)+Φt(st−1,i+1)), which is at most Φt−1(st−1,i) by Algorithm ?. This shows ∑iΦt(st,i)≤∑iΦt−1(st−1,i) and Eq. follows.

Theorem 2 tells us that if solving Φ0(0)<ϵ for R gives R>R–– for some value R––, then the regret of Algorithm ? is less than any value that is greater than R––, meaning the regret is at most R––.

Now we are ready to recover existing algorithms and develop new ones by choosing an appropriate potential ΦT(s) as Algorithm ? suggests. We will discuss three different algorithms below, and summarize these examples in Table 1 (see Appendix C).

Exponential Weights (EXP) Algorithm. Exponential loss is an obvious choice for ΦT(s) as it has been widely used as the convex surrogate of the 0-1 loss function in the literature. It turns out that this will lead to the well-known exponential weights algorithm [?]. Specifically, we pick ΦT(s) to be exp(−η(s+R)) which exactly upper bounds 1{s≤−R}. To compute Φt(s) for t≤T, we simply let Φt(s−1)+Φt(s+1)≤2Φt−1(s) hold with equality. Indeed, direct computations show that all Φt(s) share a similar form: Φt(s)=(eη+e−η2)T−t⋅exp(−η(s+R)). Therefore, according to Algorithm ?, the player’s strategy is to set

pt,i∝Φt(st−1,i−1)−Φt(st−1,i+1)∝exp(−ηst−1,i),

which is exactly the same as EXP (note that R becomes irrelevant after normalization). To derive regret bounds, it suffices to require Φ0(0)^{T} \cdot \exp−η(R)
< \epsilon,\) which is equivalent to R>1η(ln(1ϵ)+Tlneη+e−η2). By Theorem ? and Hoeffding’s lemma (see [?]), we thus know RϵT(H)≤1ηln(1ϵ)+Tη2=√2Tln(1ϵ) where the last step is by optimally tuning η to be √2(ln1ϵ)/T. Note that this algorithm is not adaptive in the sense that it requires knowledge of T and ϵ to set the parameter η.

We have thus recovered the well-known EXP algorithm and given a new analysis using the drifting-games framework. More importantly, as in [?], this derivation may shed light on why this algorithm works and where it comes from, namely, a minimax analysis followed by a series of relaxations, starting from a reasonable surrogate of the 0-1 loss function.

2-norm Algorithm. We next move on to another simple convex surrogate: ΦT(s)=a[s]2−≥1{s≤−1/√a}, where a is some positive constant and [s]−=min{0,s} represents a truncating operation. The following lemma shows that Φt(s) can also be simply described.

Thus, Algorithm 3 can again be applied. The resulting algorithm is extremely concise:

pt,i∝Φt(st−1,i−1)−Φt(st−1,i+1)∝[st−1,i−1]2−−[st−1,i+1]2−.

We call this the “2-norm” algorithm since it resembles the p-norm algorithm in the literature when p=2 (see [?]). The difference is that the p-norm algorithm sets the weights proportional to the derivative of potentials, instead of the difference of them as we are doing here. A somewhat surprising property of this algorithm is that it is totally adaptive and parameter-free (since a disappears under normalization), a property that we usually do not expect to obtain from a minimax analysis. Direct application of Theorem ? (Φ0(0)=aT<ϵ⇔1/√a>√T/ϵ) shows that its regret achieves the optimal dependence on the horizon T.

NormalHedge.DT. The regret for the 2-norm algorithm does not have the optimal dependence on ϵ. An obvious follow-up question would be whether it is possible to derive an adaptive algorithm that achieves the optimal rate O(√Tln(1/ϵ)) simultaneously for all T and ϵ using our framework. An even deeper question is: instead of choosing convex surrogates in a seemingly arbitrary way, is there a more natural way to find the right choice of ΦT(s)?

To answer these questions, we recall that the reason why the 2-norm algorithm can get rid of the dependence on ϵ is that ϵ appears merely in the multiplicative constant a that does not play a role after normalization. This motivates us to let ΦT(s) in the form of ϵF(s) for some F(s). On the other hand, from Theorem ?, we also want ϵF(s) to upper bound the 0-1 loss function 1{s≤−√dTln(1/ϵ)} for some constant d. Taken together, this is telling us that the right choice of F(s) should be of the form Θ(exp(s2/T))1. Of course we still need to refine it to satisfy the monotonicity and other properties. We define ΦT(s) formally and more generally as:

ΦT(s)=a(exp([s]2−dT)−1)≥1{s≤−√dTln(1a+1)},

where a and d are some positive constants. This time it is more involved to figure out what other Φt(s) should be. The following lemma addresses this issue (proof deferred to Appendix C).

Note that even if Φ1(s−1)+Φ1(s+1)≤2Φ0(s) is not valid in general, Lemma ? states that Eq. still holds. Thus Algorithm ? can indeed still be applied, leading to our new algorithm:

Here, d seems to be an extra parameter, but in fact, simply setting d=3 is good enough:

We have thus proposed a parameter-free adaptive algorithm with optimal regret rate (ignoring the lnlnT term) using our drifting-games framework. In fact, our algorithm bears a striking similarity to NormalHedge [?], the first algorithm that has this kind of adaptivity. We thus name our algorithm NormalHedge.DT2. We include NormalHedge in Table 1 for comparison. One can see that the main differences are: 1) On each round NormalHedge performs a numerical search to find out the right parameter used in the exponents; 2) NormalHedge uses the derivative of potentials as weights.

Compared to NormalHedge, the regret bound for NormalHedge.DT has no explicit dependence on N, but has a slightly worse dependence on T (indeed lnlnT is almost negligible). We emphasize other advantages of our algorithm over NormalHedge: 1) NormalHedge.DT is more computationally efficient especially when N is very large, since it does not need a numerical search for each round; 2) our analysis is arguably simpler and more intuitive than the one in [?]; 3) as we will discuss in Section 4, NormalHedge.DT can be easily extended to deal with the more general online convex optimization problem where the number of actions is infinitely large, while it is not clear how to do that for NormalHedge by generalizing the analysis in [?]. Indeed, the extra dependence on the number of actions N for the regret of NormalHedge makes this generalization even seem impossible. Finally, we will later see that NormalHedge.DT outperforms NormalHedge in experiments. Despite the differences, it is worth noting that both algorithms assign zero weight to some actions on each round, an appealing property when N is huge. We will discuss more on this in Section 4.

We now consider a common variant of Hedge: on each round, instead of choosing a distribution pt, the player has to randomly pick a single action it, while the adversary decides the losses ℓt at the same time (without seeing it). For now we only focus on the player’s regret to the best action: RT(i1:T,ℓ1:T)=∑Tt=1ℓt,it−mini∑Tt=1ℓt,i. Notice that the regret is now a random variable, and we are interested in a bound that holds with high probability. Using Azuma’s inequality, standard analysis (see for instance [?]) shows that the player can simply draw it according to pt=H(ℓ1:t−1), the output of a standard Hedge algorithm, and suffers regret at most RT(H)+√Tln(1/δ) with probability 1−δ. Below we recover similar results as a simple side product of our drifting-games analysis without resorting to concentration results, such as Azuma’s inequality.

For this, we only need to modify Algorithm ? by setting zt,i=ℓt,i−ℓt,it. The restriction pt⋅zt≥0 is then relaxed to hold in expectation. Moreover, it is clear that Eq. also still holds in expectation. On the other hand, by definition and the union bound, one can show that ∑iE[L(sT,i)]=∑iPr[sT,i≤−R]≥Pr[RT(i1:T,ℓ1:T)≥R]. So setting Φ0(0)=δ shows that the regret is smaller than R with probability 1−δ. Therefore, for example, if EXP is used, then the regret would be at most √2Tln(N/δ) with probability 1−δ, giving basically the same bound as the standard analysis. One draw back is that EXP would need δ as a parameter. However, this can again be addressed by NormalHedge.DT for the exact same reason that NormalHedge.DT is independent of ϵ. We have thus derived high probability bounds without using any concentration inequalities.

The only difference between Hedge (randomized version) and the non-stochastic MAB problem [?] is that on each round, after picking it, the player only sees the loss for this single action ℓt,it instead of the whole vector ℓt. The goal is still to compete with the best action. A common technique used in the bandit setting is to build an unbiased estimator ^ℓt for the losses, which in this case could be ^ℓt,i=1{i=it}⋅ℓt,it/pt,it. Then algorithms such as EXP can be used by replacing ℓt with ^ℓt, leading to the EXP3 algorithm [?] with regret O(√TNlnN).

One might expect that Algorithm ? would also work well by replacing ℓt with ^ℓt. However, doing so breaks an important property of the movements zt,i: boundedness. Indeed, Eq. no longer makes sense if z could be infinitely large, even if in expectation it is still in [−1,1] (note that zt,i is now a random variable). It turns out that we can address this issue by imposing a variance constraint on zt,i. Formally, we consider a variant of drifting games where on each round, the adversary picks a random movement zt,i for each chip such that: zt,i≥−1,Et[zt,i]≤1,Et[z2t,i]≤1/pt,i and Et[pt⋅zt]≥0. We call this variant DGv2 and summarize it in Appendix A. The standard minimax analysis and the derivation of potential functions need to be modified in a certain way for DGv2, as stated in Theorem ? (Appendix D). Using the analysis for DGv2, we propose a general recipe for designing MAB algorithms in a similar way as for Hedge and also recover EXP3 (see Algorithm ? and Theorem ? in Appendix D). Unfortunately so far we do not know other appropriate potentials due to some technical difficulties. We conjecture, however, that there is a potential function that could recover the poly-INF algorithm [?] or give its variants that achieve the optimal regret O(√TN).

Online Convex Optimization:

We next consider a general online convex optimization setting [?]. Let S⊂Rd be a compact convex set, and F be a set of convex functions with range [0,1] on S. On each round t, the learner chooses a point xt∈S, and the adversary chooses a loss function ft∈F (knowing xt). The learner then suffers loss ft(xt). The regret after T rounds is RT(x1:T,f1:T)=∑Tt=1ft(xt)−minx∈S∑Tt=1ft(x). There are two general approaches to OCO: one builds on convex optimization theory [?], and the other generalizes EXP to a continuous space [?]. We will see how the drifting-games framework can recover the latter method and also leads to new ones.

To do so, we introduce a continuous variant of drifting games (DGv3, see Appendix A). There are now infinitely many chips, one for each point in S. On round t, the player needs to choose a distribution over the chips, that is, a probability density function pt(x) on S. Then the adversary decides the movements for each chip, that is, a function zt(x) with range [−1,1] on S (not necessarily convex or continuous), subject to a constraint Ex∼pt[zt(x)]≥0. At the end, each point x is associated with a loss L(x)=1{∑tzt(x)≤−R}, and the player aims to minimize the total loss ∫x∈SL(x)dx.

OCO can be converted into DGv3 by setting zt(x)=ft(x)−ft(xt) and predicting xt=Ex∼pt[x]∈S. The constraint Ex∼pt[zt(x)]≥0 holds by the convexity of ft. Moreover, it turns out that the minimax analysis and potentials for DGv1 can readily be used here, and the notion of ϵ-regret, now generalized to the OCO setting, measures the difference of the player’s loss and the loss of a best fixed point in a subset of S that excludes the top ϵ fraction of points. With different potentials, we obtain versions of each of the three algorithms of Section 3 generalized to this setting, with the same ϵ-regret bounds as before. Again, two of these methods are adaptive and parameter-free. To derive bounds for the usual regret, at first glance it seems that we have to set ϵ to be close to zero, leading to a meaningless bound. Nevertheless, this is addressed by Theorem ? using similar techniques in [?], giving the usual O(√dTlnT) regret bound. All details can be found in Appendix E.

Applications to Boosting:

There is a deep and well-known connection between Hedge and boosting [?]. In principle, every Hedge algorithm can be converted into a boosting algorithm; for instance, this is how AdaBoost was derived from EXP. In the same way, NormalHedge.DT can be converted into a new boosting algorithm that we call NH-Boost.DT. See Appendix F for details and further background on boosting. The main idea is to treat each training example as an “action”, and to rely on the Hedge algorithm to compute distributions over these examples which are used to train the weak hypotheses. Typically, it is assumed that each of these has “edge” γ, meaning its accuracy on the training distribution is at least 1/2+γ. The final hypothesis is a simple majority vote of the weak hypotheses. To understand the prediction accuracy of a boosting algorithm, we often study the training error rate and also the distribution of margins, a well-established measure of confidence (see Appendix F for formal definitions). Thanks to the adaptivity of NormalHedge.DT, we can derive bounds on both the training error and the distribution of margins after any number of rounds:

Thus, the training error decreases at roughly the same rate as AdaBoost. In addition, this theorem implies that the fraction of examples with margin smaller than 2γ eventually goes to zero as T gets large, which means NH-Boost.DT converges to the optimal margin 2γ; this is known not to be true for AdaBoost (see [?]). Also, like AdaBoost, NH-Boost.DT is an adaptive boosting algorithm that does not require γ or T as a parameter. However, unlike AdaBoost, NH-Boost.DT has the striking property that it completely ignores many examples on each round (by assigning zero weight), which is very helpful for the weak learning algorithm in terms of computational efficiency. To test this, we conducted experiments to compare the efficiency of AdaBoost, “NH-Boost” (an analogous boosting algorithm derived from NormalHedge) and NH-Boost.DT. All details are in Appendix G. Here we only briefly summarize the results. While the three algorithms have similar performance in terms of training and test error, NH-Boost.DT is always the fastest one in terms of running time for the same number of rounds. Moreover, the average faction of examples with zero weight is significantly higher for NH-Boost.DT than for NH-Boost (see Table 3). On one hand, this explains why NH-Boost.DT is faster (besides the reason that it does not require a numerical step). On the other hand, this also implies that NH-Boost.DT tends to achieve larger margins, since zero weight is assigned to examples with large margin. This is also confirmed by our experiments.

Acknowledgements. Support for this research was provided by NSF Grant #1016029. The authors thank Yoav Freund for helpful discussions and the anonymous reviewers for their comments.

We study three different variants of drifting games throughout the paper, which corresponds to the Hedge setting, the multi-armed bandit problem and online convex optimization respectively. The protocols of these variants are summarized below.

We first show that both conversions are valid. In Algorithm ?, it is clear that ℓt,i≥0. Also, ℓt,i≤1 is guaranteed due to the extra restriction of DGv1. For Algorithm ?, zt,i lies in B=[−1,1] since ℓt,i∈[0,1], and direct computation shows pt⋅zt=0≥β(=0) and |zt,i−zt,j|=|ℓt,i−ℓt,j|≤1 for all i and j.

(1) For any choices of zt, we have

N∑i=1L(sT,i)=N∑i=1L(N∑t=1zt,i)≤N∑i=1L(N∑t=1(zt,i−pt⋅zt)),

where the inequality holds since pt⋅zt is required to be nonnegative and L is a nonincreasing function. By Algorithm ?, zt,i−pt⋅zt is equal to ℓt,i−pt⋅ℓt, leading to

N∑i=1L(sT,i)≤N∑i=1L(N∑t=1(ℓt,i−pt⋅ℓt))=N∑i=11{R≤N∑t=1(pt⋅ℓt−ℓt,i)}.

Since R(i+1)/NT(H)<R≤Ri/NT(H), we must have ∑Nt=1(pt⋅ℓt−ℓt,j)<R except for the best i actions, which means ∑Ni=1L(sT,i)≤i. This holds for any choices of zt, so LT(DR)≤i/N.

(2) By Algorithm ? and the condition LT(DR)<ϵ , we have

1NN∑i=11{R≤N∑t=1(pt⋅ℓt−ℓt,i)}=1NN∑i=1L(sT,i)≤LT(DR)<ϵ,

which means there are at most ⌈Nϵ⌉−1 actions satisfying R≤∑Nt=1(pt⋅ℓt−ℓt,i), and thus ∑Nt=1(pt⋅ℓt−ℓt,iϵ)<R. Since this holds for any choices of ℓt, we have RϵT(H)<R.

CSummary of Hedge Algorithms and Proofs of Lemma , Lemma and Corollary

Table 1: Different algorithms derived from Algorithm , and comparisons with NormalHedge

EXP

2-norm

NormalHedge.DT

NormalHedge

ΦT(s)

e−η(s+R)

a[s]2−

a(e[s]2−/3T−1)

N/A

pt,i∝

e−ηst−1,i

RϵT(H)

O(√Tln1ϵ)

O(√T/ϵ)

O(√TlnlnTϵ)

O(√Tln1ϵ+ln2N)

Adaptive?

No

Yes

Yes

Yes

It suffices to show [s−1]2−+[s+1]2−≤2[s]2−+2. When s≥0, LHS=[s−1]2−≤1<2=RHS. When s<0, LHS≤(s−1)2+(s+1)2=2s2+2=RHS.

Let F(s)=exp([s−1]2−dt)+exp([s+1]2−dt)−2exp([s]2−d(t−1)). It suffices to show

with initial values α0,0=β0,0=2 (when j∉{0,…,k}, αk,j and βk,j are all defined to be 0). Therefore, F′(s) can be further simplified as

F′(s)=2exp(s2c)∞∑k=1k∑j=0s2j+1ck+j+1(βk,j(2k)!−dkαk,jk!).

Since s is negative, it suffices to show that βk,j(2k)!≤dkαk,jk! holds for all k and j, which turns out to be true as long as d≥3, as shown by induction in the technical lemma ? below. To sum up, Φt(s−1)+Φt(s+1)≤2Φt−1(s) for all s∈R and t=2,…,T.

Finally, we need to show that Eq. (2) still holds. The inequality we just proved above implies ∑iΦt(st,i)≤∑iΦt−1(st−1,i) for t=2,…,T, as shown in Theorem ?. Thus the only thing we need to show here is the case when t=1. Note that Φ1(s−1)+Φ1(s+1)≤2Φ0(s) does not hold for all s apparently. However, in order to prove ∑iΦ1(s1,i)≤∑iΦ0(s0,i), we in fact only need a much weaker statement: Φ1(−1)+Φ1(1)≤2Φ0(0) since s0,i≡0. This is equivalent to exp(1/d)−1≤exp(4/d)−1, which is true trivially.

The base case holds trivially. Assume Eq. holds for a fixed k. Then we have

We need to show that the above expression is at most dk+1αk+1,j/(k+1)!, which, after arrangements, is equivalent to 2αk,j−1+(4j+3)αk,j+(2j+3)(j+1)αk,j+1≤d(2k+1)αk+1,j. We will prove this by another induction on k. Then the lemma follows.

The base case (k=0) is simplified to 6≤2d, which is true by our assumption d≥3. Assume the inequality holds for a fixed k, then by the definition of αk,j, one has

\tag not allowed in aligned environment

completing the induction.

Recall that ΦT(s)≥1{s≤−√dTln(1a+1)}. So by setting Φ0(0)=a(1−b0)<ϵ and applying Theorem ?, we arrive at

RϵT(H)≤√dTln(1−b0ϵ+1).

It suffices to upper bound 1−b0, which, by definition, is 12∑Tt=1(exp(4dt)−1). Since ex−1≤ec−1cx for any x∈[0,c], we have

As discussed before, the main difficulty here is the unboundedness of zt,i. However, the expectation of zt,i is still in [−1,1] as in DGv1. To exploit this fact, we apply Taylor’s theorem to Φt(st−1,i+zt,i) to the second order term: