On Elimination Strategies for Bandit Fixed-Confidence Identification
Abstract
Elimination algorithms for bandit identification, which prune the plausible correct answers sequentially until only one remains, are computationally convenient since they reduce the problem size over time.
However, existing elimination strategies are often not fully adaptive (they update their sampling rule infrequently) and are not easy to extend to combinatorial settings, where the set of answers is exponentially large in the problem dimension.
On the other hand, most existing fully-adaptive strategies to tackle general identification problems are computationally demanding since they repeatedly test the correctness of every answer, without ever reducing the problem size.
We show that adaptive methods can be modified to use elimination in both their stopping and sampling rules, hence obtaining the best of these two worlds: the algorithms (1) remain fully adaptive, (2) suffer a sample complexity that is never worse of their non-elimination counterpart, and (3) provably eliminate certain wrong answers early.
We confirm these benefits experimentally, where elimination improves significantly the computational complexity of adaptive methods on common tasks like best-arm identification in linear bandits.
Introduction
The multi-armed bandit is a sequential decision-making task which is now extensively studied (see, e g., [1] for a recent review).
In this problem, an algorithm interacts with its environment by sequentially “pulling” one among K ∈ N arms and observing a sample from a corresponding distribution.
Among the possible objectives, we focus on fixed-confidence identification [2, 3, 4, 5].
In this setting the algorithm successively collects samples until it decides to stop and return an answer to a given query about the distributions.
Its task is to return the correct answer with at most a given probability of error δ and its secondary goal is to do so while stopping as early as possible.
This problem is called “fixed-confidence” as opposed to “fixed-budget”, where the goal is to minimize the error probability with at most a given number of samples [6, 7, 8, 9, 10].
The most studied query is best arm identification (BAI), where the aim is to return the arm whose distribution has highest mean.
A variant is Top-m identification [11], where the goal is to find the m arms with highest means.
While these are the most common, other queries have been studied, including thresholding bandits [9], minimum threshold [12], and multiple correct answers [13].
Algorithms for fixed-confidence identification can be generally divided into two classes: those based on adaptive sampling and those based on elimination .
Adaptive algorithms
[e.g., 8, 11, 4, 14] update their sampling strategy at each round and typically stop when they can simultaneously assess the correctness of every answer.
They often enjoy strong theoretical guarantees.
For instance, some of them [4, 15, 16, 17] have been shown to be optimal as δ → 0 .
However, since they repeatedly test the correctness of every answer, they are often computationally demanding.
Elimination-based strategies [e.g., 2, 18, 19, 20, 21] maintain a set of “active” answers (those that are still likely to be the correct one) and stop when only one remains.
They typically update their sampling rules and/or the active answers infrequently.
This, together with the fact that eliminations reduce the problem size over time, makes them more computationally efficient but also yields large sample complexity in practice.
Moreover, while adaptive algorithms for general identification problems (i.e., with arbitrary queries) exist [4, 15, 17], elimination-based strategies are not easy to design at such a level of generality.
In particular, they are not easy to extend to structured combinatorial problems (such as Top-m), where the number of answers is exponential in the problem dimension.
In this paper, we design a novel elimination rule for general identification problems which we call selective elimination.
It can be easily combined with existing adaptive strategies, both in their stopping and sampling rules, making them achieve the best properties of the two classes mentioned above.
In particular, we prove that (1) selective elimination never suffers worse sample complexity than the original algorithm, and hence remain asymptotically optimal whenever the base algorithm is; (2) It provably discards some answers much earlier than the stopping time; (3) It improves the computational complexity of the original algorithm when some answers are eliminated early.
Experimentally, we compare several existing algorithms for three identification problems (BAI,
Top-m, and thresholding bandits) on two bandit structures (linear and unstructured).
We find that, coherently across all experiments, existing adaptive strategies achieve significant gains in computation time and, to a smaller extent, in sample complexity when combined with selective elimination.
1.1 Bandit fixed-confidence identification
An algorithm interacts with an environment composed of K > 1 arms .
At each time t ∈ N , the algorithm picks an arm k t and observes X k t t ∼ ν k t , where ν k t is the distribution of arm k t .
At a time τ , the algorithm stops and returns an answer ˆ ı from a finite set I .
Formally, let F t be the σ -algebra generated by the observations up to time t .
An identification algorithm is composed of
Sampling rule : the sequence ( k t ) t ∈ N , where k t is F t − 1 -measurable.
Stopping rule : a stopping time τ with respect to ( F t ) t ∈ N and a random variable ˆ ı ∈ I , i.e., the answer returned when stopping at time τ .
Note that, while it is common to decouple τ and ˆ ı , we group them to emphasize that the time at which an algorithm stops depends strongly on the answer it plans on returning.
We assume that the arm distributions depend on some unknown parameter θ ∈ M , where M ⊆ R d is the set of possible parameters, and write ν k ( θ ) for k ∈ [ K ] to make this dependence explicit.
For simplicity, we shall use θ to refer to the bandit problem ( ν k ( θ ))
k ∈ [ K ] .
This assumption allows us to include linear bandits in our analysis.
We let i ⋆ : M → I be the function, known to the algorithm, which returns the unique correct answer for each problem.
The algorithm is correct on θ if ˆ ı = i ⋆ ( θ ) .
Definition 1.1 ( δ -correct algorithm) .
An algorithm is said to be δ -correct on M ⊆ R d if for all θ ∈ M , τ < + ∞ almost surely and P θ
(ˆ ı ̸
= i ⋆ ( θ ))
≤ δ .
We want to design algorithms that, given a value δ , are δ -correct on M and have minimal expected sample complexity E θ
[ τ ] for all θ ∈ M .
A lower bound on E θ [ τ ] was proved in [4].
In order to present it, we introduce the concept of alternative set to an answer i ∈
I : Λ( i ) :
= { λ ∈ M | i ⋆ ( λ )
̸ = i } , the set of parameters for which the correct answer is not i .
Let us denote by KL k ( θ, λ ) the KullbackLeibler (KL) divergence between the distribution of arm k under θ and λ .
Then the lower bound states that for any algorithm that is δ -correct on M and any problem θ ∈ M ,
[Equation]
Example: BAI in Gaussian linear bandits While our results apply to general queries, we illustrate all statements of this paper on the widely-studied task of BAI in Gaussian linear bandits [19, 14, 23, 16, 24].
In this setting, each arm k ∈
[ K ] has a Gaussian distribution N ( µ k ( θ ) , 1) with mean µ k ( θ ) =
ϕ
⊤ k θ , a linear function of the unknown parameter θ ∈ R d (and M = R d ) and of known arm features ϕ k ∈ R d .
The set of answers is I =
[ K ] and the correct answer is i ⋆ ( θ ) :
= arg max k ∈
[ K ] ϕ ⊤ k θ .
Finally, for x ∈ R d and A ∈ R d × d , we define ∥ x
∥ A := √ x ⊤ Ax .
For ω ∈ R K , let V ω :
= (cid:80)
Kk =1 ω k ϕ k ϕ ⊤ k .
With this notation, we have
[Equation]
1.2 Log-likelihood ratio stopping rules
Most existing adaptive algorithms use a log-likelihood ratio (LLR) test in order to decide when to stop.
Informally, they check whether sufficient information has been collected to confidently discard at once all answers except one.
Since such LLR tests are crucial for the design of our general elimination rules, we now describe their principle.
Given two parameters θ, λ ∈ M , the LLR of observations X [ t ] =
( X k 1 1 , . . .
, X k t t ) between models θ and λ is L t ( θ, λ ) :=
log d P θ d P λ ( X [ t ] )
= (cid:80) ts =1 log d P θ d P λ ( X k s s ) .
Let ˆ θ t := arg max λ ∈M log P λ
( X [ t ] ) be the maximum likelihood estimator of θ from t observations.
In Gaussian linear bandits, we have L t ( θ, λ ) =
12 ∥
θ − λ
∥ 2 V Nt + ( θ − λ )
⊤ V N t (ˆ θ t − θ ) , where N kt := (cid:80) ts =1 1 ( k s = k ) .
See
Appendix C for more details.
L t ( θ, λ ) is closely related to
[Equation]
Kk
[Equation]
λ ) , a quantity that appears frequently in our results.
Indeed, the difference between these quantities is a martingale, which is a lower order term compared to them.
The LLR stopping rule was introduced to the bandit literature in [4].
At each step t ∈ N , the algorithm computes the infimum LLR to the alternative set of i ⋆
(ˆ θ t ) and stops if it exceeds a threshold, i.e., if
[Equation]
where the function β t,δ can vary, notably based on the shape of the alternative sets.
The recommendation rule is then ˆ ı = i ⋆ (ˆ θ t ) .
Informally, the algorithm stops if it has enough information to exclude all points λ for which the answer is not i ⋆
(ˆ θ t ) .
This stopping rule enforces δ -correctness, provided that the sampling rule ensures τ < + ∞ a.s. and that β t,δ is properly chosen.
The most popular choice is to ensure a concentration property of L t (ˆ θ t , θ ) .
For example, if for all δ , β t,δ guarantees that
[Equation]
LLR stopping with that threshold returns a wrong answer with probability at most δ .
Such concentration bounds can be found in [25, 26] for linear and unstructured bandits, respectively.
This LLR stopping rule is used in many algorithms [4, 14, 15, 16, 24, 17] 3 .
Some of them have been proven to be asymptotically optimal : their sample complexity upper bound matches the lower bound (1) when δ → 0 .
However, improvements are still possible: their sample complexity for moderate δ may not be optimal and their computational complexity may be reduced, as we will see.
Elimination stopping rules for adaptive algorithms
We show how to modify the stopping rule of adaptive algorithms using LLR stopping to perform elimination.
We assume that the alternatives sets Λ( i ) can be decomposed into a union of sets which we refer to as alternative pieces (or simply pieces), with the property that computing the infimum
LLR over these sets is computationally easy.
Assumption 2.1.
For all i ∈ I , there exist pieces (Λ p ( i ))
p ∈P ( i ) , where P ( i ) is a finite set of piece indexes, such that Λ( i ) =
(cid:83) p ∈P ( i ) Λ p ( i ) and inf λ ∈
Λ p ( i )
L t (ˆ θ t , λ ) can be efficiently computed for all p ∈ P ( i ) and t > 0 .
This assumption is satisfied in many problems of interest, including BAI, Top- m identification, and thresholding bandits (see Appendix B).
Indeed, in all applications we consider in this paper, the sets of Assumption 2.1 are half-spaces.
In our linear BAI example, the piece indexes are simply arms.
For i, j ∈ [ K ] we can define Λ j ( i ) =
{ λ ∈ M | ϕ ⊤ j λ > ϕ ⊤ i λ } .
Then, Λ( i ) =
(cid:83) j ∈ [ K ] \{ i } Λ j ( i ) .
Moreover, the infimum LLR (and the corresponding minimizer) can be computed in closed form as
[Equation]
Elimination stopping The main idea is that it is not necessary to exclude all Λ p ( i ) for p ∈ P ( i ) at the same time , as LLR stopping (2) does 4 , in order to know that the algorithm can stop and return answer i .
Instead, each piece can be pruned as soon as we have enough information to do so.
Definition 2.2.
A set S ⊆
R d is said to be eliminated at time t if, for all λ ∈ S , L t (ˆ θ t , λ ) ≥ β t,δ .
From the concentration property (3), we obtain that the probability that θ ∈ S and S is eliminated is less than δ .
LLR stopping interrupts the algorithm when the alternative set Λ( i ⋆ (ˆ θ t )) can be eliminated.
In elimination stopping, we eliminate smaller sets gradually, instead of the whole alternative at once.
Formally, let us define, for all
i ∈
I ,
[Equation]
as the subset of pieces for answer i ∈ I whose infimum LLR at time t is below a threshold β t,δ .
That is, the indexes of pieces that are not eliminated at time t .
Moreover, we define, for all i ∈ I , a set of active pieces P stp t ( i ) which is initialized as P stp0 ( i ) =
P ( i ) (all piece indexes).
Our selective elimination rule updates, at each time t , only the active pieces of the empirical answer i ⋆ (ˆ θ t ) .
That is, for i
=
i ⋆
(ˆ θ t ) , it sets
[Equation]
while it sets P stp t ( i ) :
= P stp t − 1 ( i ) for all i ̸
= i ⋆
(ˆ θ t ) .
One might be wondering why not updating all answers at each round.
The main reason is computational: as we better discuss at the end of this section, checking LLR stopping requires one minimization for each piece p ∈ P ( i ⋆ (ˆ θ t )) , while selective elimination requires only one for each active piece p ∈ P stp t − 1 ( i ⋆ (ˆ θ t )) .
Thus, the latter becomes increasingly more computationally efficient as pieces are eliminated.
For completeness, we also analyze the variant, that we call full elimination , which updates the active pieces according to (5) for all answers i ∈
I at each round.
While we establish slightly better theoretical guarantees for this rule, it is computationally demanding and, as we shall see in our experiments, it does not significantly improve sample complexity w.r.t.
selective elimination, which remains our recommended choice.
Let τ s .
elim = inf t ≥ 1 { t | P stp t ( i ⋆ (ˆ θ t )) = ∅} and τ f . elim :
= inf t ≥ 1 { t | ∃ i ∈ I : P stp t ( i ) = ∅} be the stopping times of selective and full elimination, respectively.
Intuitively, these two rules stop when one of the updated answers has all its pieces eliminated (and return that answer).
We show that, as far as β t,δ is chosen to ensure concentration of ˆ θ t to θ , those two stopping rules are δ -correct.
Lemma 2.3 ( δ -correctness) .
Suppose that β t,δ guarantees (3) and that the algorithm verifies that, whenever it stops, there exists i ∅ ∈
I such that P stp τ ( i ∅ ) = ∅ and ˆ ı = i ∅ .
Then, P θ (ˆ ı ̸
= i ⋆ ( θ )) ≤ δ .
All proofs for this section are in Appendix D.
If an algorithm verifies the conditions of Lemma 2. and has a sampling rule that makes it stop almost surely, then it is δ -correct.
Interestingly, we can prove a stronger result than δ -correctness: under the same sampling rule, the elimination stopping rules never trigger later than the LLR one almost surely .
In other words, any algorithm equipped with elimination stopping suffers a sample complexity that is never worse than the one of the same algorithm equipped with LLR stopping.
Let τ llr :=
inf t ≥ 1 { t | inf λ ∈ Λ( i ⋆ (ˆ θ t ))
L t (ˆ θ t , λ ) ≥ β t,δ } .
Theorem 2.4.
For any sampling rule, almost surely τ f . elim ≤ τ s .
elim ≤ τ llr .
The proof of this theorem is very simple: if τ llr = t , then at t all pieces Λ p ( i ⋆ (ˆ θ t )) for p ∈ P ( i ⋆ (ˆ θ t )) can be eliminated, hence τ s .
elim ≤ t .
The proof that τ f . elim ≤ τ s .
elim follows from the observation that full elimination always has less active pieces than selective elimination.
Note that all three stopping rules must use the same threshold β t,δ to be comparable.
Although simple, Theorem 2. has an important implication: we can take any existing algorithm that uses LLR stopping, equip it with elimination stopping instead, and obtain a new strategy that is never worse in terms of sample complexity and for which the original theoretical results on the stopping time still hold.
Finally, it is important to note that, while defining the elimination rule in the general form (5) allows us to unify many settings, storing/iterating over all sets P stp t ( i ) would be intractable in problems with large number of answers (e.g., top-m identification or thresholding bandits, where the latter is exponential in K ).
Fortunately, we show in Appendix B that this is not needed and efficient implementations exist for these problems that take only polynomial time and memory.
2.1 Elimination time of alternative pieces
We now show that elimination stopping can indeed discard certain alternative pieces much earlier that the stopping time.
While all results so far hold for any distribution and bandit structure, in the remaining we focus on Gaussian linear bandits.
Other distribution classes beyond Gaussians could be used with minor modifications (see Appendix C.2) but the Gaussian case simplifies the exposition.
Since most existing adaptive sampling rules target the optimal proportions from the lower bound of [4], we unify them under the following assumption.
Assumption 2.5.
Consider the concentration events
[Equation]
A sampling rule is said to have low information regret if there exists a problem-dependent function
R ( θ, t ) which is sub-linear in t such that for each time t where E t holds,
[Equation]
The left-hand side of (7) can be understood as the information collected by the sampling rule at time t to discriminate θ with all its alternatives.
Therefore, Assumption 2.5 requires that information to be comparable (up to a low-order term R ( θ, t ) ) with the maximal one from the lower bound.
In
Appendix F, we show that this is satisfied by both Track-and-Stop [4] and the approach in [15].
Let H p ( ω, θ ) :
= inf λ ∈ Λ p
( i ⋆ ( θ ))
(cid:80)
k ∈
[ K ] ω k KL k ( θ, λ ) , the information that sampling with proportions ω brings to discriminate θ from the alternative piece Λ p ( i ⋆ ( θ )) .
Note that
[Equation]
For ϵ ≥ 0 , let Ω ϵ ( θ ) :
= { ω ∈ ∆ K | inf
[Equation]
( i ⋆ (
[Equation]
θ
[Equation]
− ϵ } be the set of ϵ -optimal proportions.
Theorem 2.6 (Piece elimination) .
The stopping time of any sampling rule having low information regret, combined with LLR stopping, satisfies E [ τ ] ≤ ¯ t + 2 , where ¯ t is the first integer such that
[Equation]
When the same sampling rule is combined with elimination stopping, let τ p be the time at which p ∈ P
( i ⋆ ( θ )) is eliminated.
Then, E [ τ p ] ≤ min { ¯ t p , ¯ t } + 2 , where ¯ t p is the first integer such that
[Equation]
with G ( θ, t ) = 0 for full elimination and G ( θ, t ) = 4 β t, 1 /t 2 + R ( θ,t ) H ⋆ ( θ ) for selective elimination.
First, the bound we obtain on the elimination time of pieces in P ( i ⋆ ( θ )) is not worse than the bound we obtain on the stopping time of LLR stopping.
Second, with elimination stopping, such eliminations can actually happen much sooner.
Intuitively, sampling rules with low information regret play arms with proportions that are close to the optimal ones.
If all of such “good” proportions provide large information for eliminating some piece p ∈ P ( i ⋆ ( θ )) , then p is eliminated much sooner than the actual stopping time (which requires eliminating the worst-case piece in the same set).
While both elimination rules are provably efficient, with full elimination enjoying slighly better guarantees 5 , selective elimination provably never worsens (and possibly improves) the computational complexity over LLR stopping.
In all applications we consider, implementing LLR stopping requires one minimization for each of the same alternative pieces we use for elimination stopping.
Therefore, the total number of minimizations required by LLR stopping is
[Equation]
| versus (cid:80)
[Equation]
s .
elim t =
|P stp t ( i ⋆ (ˆ θ t ))
| for selective elimination.
The second is never larger since τ s .
elim ≤ τ llr by Theorem 2.4 and P stp t ( i ⋆ (ˆ θ t )) ⊆
P ( i ⋆ (ˆ θ t )) for all t , and much smaller if eliminations happen early, as we shall verify in experiments.
In our linear BAI example we need to perform ( K − 1) minimizations at each step, one for each sub-optimal arm, in order to implement LLR stopping.
On the other hand, we need only |P
stp t ( i ⋆ (ˆ θ t )) | minimizations with selective elimination, one for each active sub-optimal arm, while full elimination takes (cid:80)
[Equation]
to update all the sets.
Note that Theorem 2.6 does not provide a better bound on E [ τ ] for elimination stopping than for LLR stopping.
In fact, when evaluating the bound on E [ τ p ] for the worst-case piece in p ∈ P
( i ⋆ ( θ )) , we recover the one on E [ τ ] .
This is intuitive since the sampling rule is playing proportions that try to eliminate all alternative pieces at once.
The following result formalizes this intuition.
Theorem 2.7.
Suppose that we can write β t,δ = log 1 δ + ξ ( t, δ ) with lim δ
→ 0 ξ ( t, δ ) / log(1 /δ )
= 0 .
Then for any sampling rule that satisfies Assumption 2.5,
[Equation]
+ f ( θ, δ ) .
with lim δ → 0 f ( θ, δ ) / log(1 /δ )
= 0 .
Here τ elim can stand for either full or selective elimination.
See Appendix D.4 for f .
This result shows that when the sampling rule is tailored to the LLR stopping rule, the expected LLR and elimination stopping times differ by at most low-order (in log(1 /δ ) )
terms.
As δ → 0 the two expected stopping times converge to the same value H ⋆ ( θ ) − 1 log(1 /δ ) , which is the asymptotically-optimal sample complexity prescribed by the lower bound (1).
We showed that, for both elimination rules, some pieces of the alternative are discarded sooner than the stopping time, and that the overall sample complexity of the method can only improve over LLR stopping.
However, since the sampling rule of the algorithm was not changed, elimination does not change the computational cost of each sampling step, only the cost of checking the stopping rule.
2.2 An example
We compare LLR and elimination stopping on a simple example so as to better quantify the elimination times of Theorem 2.6 and their computational impact (see Appendix H.1 for a full discussion).
[Figure]
Consider BAI in a Gaussian linear bandit instance with unit variance, d = 2 , and arbitrary number of arms K ≥ 3 (see Figure 1).
The arm features are ϕ 1 = (1 , 0) T , ϕ
= (0 , 1) T , and, for all i = 3 , . . .
, K , ϕ i
= ( a i , b i ) T with a i , b i arbitrary values in ( − 1 , 0)
such that ∥ ϕ i ∥ 2 = 1 .
The true parameter is θ =
(1 , 1 − ε ) T , for ε ∈ (0 , 1 / 2) a possibly very small value.
Arm 1 is optimal with mean µ 1 ( θ ) = 1 , while arm 2 is sub-optimal with mean µ 2 ( θ ) = 1 − ε .
For all other arms i = 3 , . . .
, K , µ i ( θ ) ≤ 0 .
Let
ω ∈ ∆ K be any allocation.
Recall that in BAI each piece index is simply an arm, and P ( i ⋆ ( θ ))
=
P (1) = { 2 , . . .
, K } .
Let k ∈
P (1) be any sub-optimal arm.
The distance to the k -th alternative piece H k ( ω, θ ) can be computed in closed form as H k ( ω, θ )
=
(( ϕ 1 − ϕ k ) T θ ) 2 / (2 ∥
ϕ 1 − ϕ k ∥ 2 V − 1 ω ) .
The optimal allocation is
[Equation]
The intuition why this example is interesting is as follows.
Any correct strategy is required to discriminate between arm 1 and(i.e., to figure out that arm 1 is optimal), which requires roughly O (1 /ε 2 ) samples from both.
An optimal strategy plays these two arms nearly with the same proportions.
Since ϕ 1 and ϕ 2 form the canonical basis of R 2 , the samples collected by this strategy are informative for estimating the mean reward of every arm, even those than are not played.
Then, since arms 3 , . . .
, K have at least a sub-optimality gap of 1 , an elimination-based strategy discards them with a number of samples not scaling with 1 /ε 2 .
This means that a non-elimination strategy runs for O (1 /ε 2 ) steps over the original problem with K arms, while an elimination-based one quickly reduces the problem to one with only 2 arms.
The main impact is computational: since most algorithms need to compute some statistics for each active arm at each round (e.g., closest alternatives, confidence intervals, etc.), the computational complexity of a non-elimination algorithm is at least O ( K/ε 2 ) , while the one of an elimination-based variant is roughly O
( K + 1 /ε 2 ) , a potentially very large improvement.
We now quantify the elimination times and computational complexity on this example.
Since such quantities depend on the specific sampling rule, we do it for an oracle strategy that samples according to ω ⋆ .
Similar results can be derived for any low information regret sampling rule (see Appendix H.1).
Proposition 2.8.
For any K ≥ 3 and ε ∈ (0 , 1 / 2) , for any δ ∈ (0 , 1) , the oracle strategy combined with LLR stopping satisfies on the example instance
[Equation]
On the same instance, for the oracle strategy with elimination at stopping and a threshold β t,δ = log(1 /δ )
+ O (log( t )) , the expected elimination time of any piece (i.e., arm) k ≥ 3 is
E [ τ k ] ≤ (cid:101)
O (log(1 /δ )) for full elimination ,
E
[Equation]
for selective elimination .
Moreover, the expected per-round computation time of the oracle strategy with LLR stopping is Ω( K ) , while it is at most O ( K 2 ε 2 ) for full elimination and O ( Kε 2 + K/ log(1 /δ )) for selective elimination.
Elimination at sampling
We show how to adapt sampling rules in order to accommodate piece elimination.
There are two reasons for doing this: first, adapting the sampling to ignore pieces that have been discarded could reduce the sample complexity; second, the amount of computations needed to update the sampling strategy is often proportional to the number of pieces and decreasing it can reduce the overall time.
We start from an algorithm using LLR stopping, for which we change the stopping rule as above.
The sampling strategies that we can adapt are those that aggregate information from each alternative piece.
For example, in linear BAI, methods that mimic the lower bound allocation (1), like Track-and-Stop [4], LinGame [16], or FWS [17], and even LinGapE [14], all compute distances or closest points to each piece in the decomposition { λ | ϕ ⊤ j λ ≥ ϕ ⊤ i ⋆ (ˆ θ t ) λ } .
Eliminating pieces at sampling simply means omitting from such computations the arms that were deemed sub-optimal.
Algorithm 1 shows how Track-and-Stop [4] can be modified to incorporate elimination at sampling and stopping.
Algorithm while not stopped do for p ∈ P ( i ⋆ (ˆ θ t )) do ▷ stopping
L p,t = inf λ ∈ Λ p ( i ⋆ (ˆ θ t ))
L t (ˆ θ t , λ ) end for if ∀ p ∈ P
( i ⋆ (ˆ θ t )) :
L p,t > β t,δ then STOP w t = arg max ω min p ∈P ( i ⋆ (ˆ θ t ))
H p ( ω, ˆ θ t )
if ∃ k : N kt < √ t pull k t +1 =
arg min
k N kt else pull k t +1 = arg min k ( N kt − tw kt ) end while while not stopped do
Set P stp t ( i ⋆ (ˆ θ t )) =
P stp t − 1 ( i ⋆ (ˆ θ t )) for p ∈ P stp t − 1 ( i ⋆ (ˆ θ t )) do ▷ stopping
L p,t = inf λ ∈ Λ p ( i ⋆ (ˆ θ t ))
L t (ˆ θ t , λ ) if L p,t > β t,δ delete p from P stp t ( i ⋆ (ˆ θ t )) end for if P stp t ( i ⋆ (ˆ θ t ))
= ∅ then STOP w t = arg max ω min p ∈P smp t ( i ⋆ (ˆ θ t ))
H p ( ω, ˆ θ t )
if ∃ k : N kt < √ t pull k t +1 =
arg min
k N kt else pull k t +1 = arg min k ( N kt − tw kt )
Update P smp t +
( i ⋆ (ˆ θ t ))
(Algorithm 3) end while
Similarly to elimination stopping, the idea is to maintain sets of active pieces at sampling P smp t ( i ) for each i ∈
I .
Note that these are different from the ones introduced in Section 2 for the stopping rule.
The set is updated at each step like we did for the stopping sets, but with a different threshold α t,δ (see Appendix E for details).
Additionally, we reset it very infrequently at steps t ∈ { ¯ t 2 j 0 } j ≥ 0 , where ¯ t 0 ≥ 2 .
Formally, let us define the helper sets ˜ P smp t ( i ) as ˜ P smp0 ( i ) :
= P ( i ) and ˜ P smp
[Equation]
( i ) :
[Equation]
otherwise , where P t was defined in (4).
Let t j :=
¯ t 2 j 0 be the time step at which the j -th reset is performed and j ( t ) :=
⌊ log 2 log ¯ t 0 t ⌋ be the index of the last reset before t .
We define P smp t ( i ) :
=
˜ P smp t ( i ) ∩ ˜ P
smp t j ( t ) − 1 ( i ) , such that P smp t ( i ) is the intersection of all active pieces from the second-last reset up to t
, i.e., P smp t ( i ) = (cid:84) ts =
t j ( t ) − 1 P s ( i ; α s,δ ) .
Since the resets are very infrequent, this definition only drops a small number of rounds from the intersection (less than √ t ).
The detailed procedure to update these sets is summarized in Algorithm 3.
As before, we can instantiate both selective and full elimination.
The reason for the resets is two-fold.
First, they ensure that the algorithm stops almost surely as required by Definition 1.1.
In fact, without resets, it might happen with some small (less than δ ) probability that pieces containing the true parameter are eliminated, in which case the sampling rule could diverge.
Second, they guarantee that the thresholds ( α s,δ ) t s = t j ( t ) − 1 used in P smp t ( i ) are within a constant factor of each other.
This is crucial to relate the LLR of active pieces at different times.
3.1 Properties
We consider a counterpart of Assumption 2.5 for sampling rules combined with piece elimination.
Assumption 3.1.
There exists a sub-linear (in t ) problem-dependent function R ( θ, t ) such that, for each time t where E t (defined in Equation 6) holds,
[Equation]
Intuitively, the sampling rule maximizes the information for discriminating θ with all its alternatives from the sequence of active pieces ( P smp s − 1 ( i ⋆ ( θ )))
ts =1 .
We prove in Appendix F that the algorithms for which we proved Assumption 2.5 also satisfy Assumption 3.1 when their sampling rules are combined with either full or selective elimination.
Theorem 3.2.
Consider a sampling rule that verifies Assumption 3.1 and uses either full or selective elimination with the sets P smp t .
Then, Assumption 2.5 holds as well.
Moreover, when using the same elimination rule at stopping, such a sampling rule verifies Theorem 2.6, i.e., it enjoys the same guarantees as without elimination at sampling.
The proof is in Appendix E. Theorem 3.2 shows that for an algorithm using elimination at sampling and stopping, we get bounds on the times at which pieces of Λ( i ⋆ ( θ )) are discarded from the stopping rule which are not worse than those we obtained for the same algorithm without elimination at sampling.
This result is non-trivial.
We know that the sampling rule collects information to discriminate θ with its closest alternatives, and eliminating a piece cannot make the resulting “optimal” proportions worse at this task.
However, it could make them worse at discriminating θ with alternatives that are not the closest.
This would imply that the elimination times for certain pieces could actually increase w.r.t.
not eliminating at sampling.
Theorem 3.2 guarantees that this does not happen: eliminating pieces at sampling cannot worsen our guarantees.
We shall see in our experiments that eliminating pieces in both the sampling and stopping rules often yields improved sample complexity.
Experiments
Our experiments aim at addressing the following questions: (1) how do existing adaptive strategies behave when combined with elimination at stopping and (when possible) at sampling?
How do they compare with native elimination-based methods?
(2) What is the difference between selective and full elimination?
(3) How do LLR and elimination stopping compare as a function of δ ?
We ran experiments on two bandit structures: linear (where d < K ) and unstructured (where K = d and the arms are the canonical basis of R d ).
For each of them, we considered 3 pure exploration problems: BAI, Top-m, and online sign identification (OSI) [9, 27], also called thresholding bandits.
All experiments use δ = 0 .
and are averaged over 100 runs.
We combined adaptive algorithms which are natively based on LLR stopping with our elimination stopping rules and, whenever possible, we extended their sampling rule to use elimination.
The selected baselines are the following.
For linear BAI, LinGapE [14], LinGame [16],
Frank-Wolfe
Sampling (FWS) [17], Lazy Track-and-Stop (TaS)
[24], XY-Adaptive [19], and RAGE [20] (the latter two are natively elimination based).
For linear Top-m, m-LinGapE [28], MisLid [29], FWS, Lazy
TaS 7 , and LinGIFA [28].
For linear OSI, LinGapE 8 , LinGame, FWS, and Lazy TaS. For unstructured instances linear algorithms are still applicable, and we further implemented LUCB [11], UGapE [8], and the Racing algorithm [18] for BAI and Top-m. We also tested an “oracle” sampling rule which uses the optimal proportions from the lower bound.
Due to space constraints, we present only the results on linear structures.
Those on unstructured problems can be found in Appendix G.
The first experiments use randomly generated instances with K = 50 arms and dimension d = 10 .
Comparison of elimination times.
We analyze how different adaptive algorithms eliminate pieces when combined with selective elimination at stopping.
To this purpose we focus on BAI, where the sets of pieces can be conveniently reduced to a set of active arms, those that are still likely to be the optimal one.
Figure 2 (left) shows how the set of active arms evolves over time for the 5 adaptive baselines.
Notably, many arms are eliminated very quickly, with most baselines able to halve the set of active arms in the first 3000 steps.
The problem size is quickly reduced over time.
As we shall see in the last experiment, this will yield significant computational gains.
We further note that the “oracle” strategy, which plays fixed proportions, seems the slowest at eliminating arms.
The reason is that the optimal proportions from the lower bound focus on discriminating the “hardest” arms, while the extra randomization in adaptive rules might indeed eliminate certain “easier” arms sooner.
Full versus selective elimination.
We combine the different algorithms with full and selective elimination, both at sampling and stopping.
Due to space constrains, Figure 2 (middle) shows the results only for LinGame (see Appendix G for the others).
We note that full elimination seems faster at discarding arms in earlier steps, as we would expect theoretically.
However, it never stops earlier than its selective counterpart.
Moreover, its computational overhead is not advantageous.
Overall, we concluded that our selective elimination rule is the best choice and we shall thus focus on it in the remaining.
Finally, we remark that combining the sampling rule with elimination (no matter of what type) seems to discard arms faster in later steps, and could eventually make the algorithm stop sooner.
LLR versus elimination stopping.
We now compare LLR and elimination stopping as a function of δ .
We know from theory that both stopping rules allow to achieve asymptotic optimality.
Hence for asymptotically optimal sampling rules the resulting stopping times with LLR and elimination should tend to the same quantity as δ → 0 .
Figure 2 (right) , where we report the ratio between the
LLR stopping time and the elimination one for different algorithms, confirms that this is the case.
Some algorithms (LinGapE and FWS) seem to benefit less from elimination stopping than the others,
[Table] [Table]
[Table]
Sample complexities and computation times.
We finally compare our baselines in all three exploration tasks, in terms of sample complexity and computation time.
For this experiment, we selected a larger linear instance with K = 50 and d = 20 , randomly generated (see the protocol in Appendix G).
From the results in Table 1, we highlight three points.
(1) The computation times of all adaptive algorithms decrease when using selective elimination stopping instead of LLR and further decrease when also using elimination at sampling.
In the case of Top-m (i
[Table]
e., the hardest combinatorial problem), most adaptive algorithms become at least twice faster with elimination at stopping and sampling instead of LLR.
(2) Elimination at sampling improves the sample complexity of all algorithms.
(3) For BAI, the natively elimination-based algorithm RAGE, which updates its strategy infrequently, is the fastest in terms of computation time but the slowest in terms of samples.
Adaptive algorithms using elimination achieve run times that are within an order of magnitude of those of RAGE, while outperforming it in terms of sample complexity by a factor 2 to 3.
Conclusion
We proposed a selective elimination rule, which successively prunes the pieces of the empirical answer, that can be easily combined with existing adaptive algorithms for general identification problems.
We proved that it reduces their computational complexity, it never worsens their sample complexity guarantees, and it provably discards certain answers early.
Our experiments on different pure exploration problems and bandit structures show that existing adaptive algorithms often benefit from a reduced sample complexity when combined with selective elimination, while achieving significant gains in computation time.
Moreover, they show that selective elimination is overall better (in terms of samples vs time) than its full variant which repeatedly updates the pieces of all answers.
Interesting directions for future work include investigating whether better guarantees on the stopping time can be derived for algorithms combined with elimination as compared to their LLR counterparts, and designing adaptive algorithms which are specifically tailored for elimination. G Experiment Details and Additional Results [Table] [Table]
[Table] H Examples [Table] [Table]
with
[Table]
t. LLR
[Table]
[Table]
3 Low information regret with elimination at stopping provably discards many
[Table]
I Additional details
A
Notation [Table] B Identification Problems In this section, we show that popular identification problems satisfy Assumption 2.1 and are thus suitable for elimination-based algorithms.
We shall focus on Gaussian linear bandits , where, for any θ ∈ M and k ∈ [ K ] , ν k ( θ ) is Gaussian with unit variance and linear mean µ k ( θ )
= θ T ϕ k .
For each identification problem, we first show how to decompose the sets of alternatives into pieces for which the closest alternatives can be found efficiently.
Moreover, we report the closed-form equations for computing such closest alternatives in Gaussian linear bandits and in the special case of unstructured bandits (where M = R K and ϕ k = e k , the canonical basis of R k ).
Finally, we show how to efficiently implement elimination strategies in each of these identification problems even when enumerating over all possible answers is intractable (e.g., for problems where the number of answers is exponential in the problem dimension).
The LLR in Gaussian linear bandits For all identification problems presented later, we need to show that inf
λ ∈ Λ p ( i )
L t (ˆ θ, λ ) can be computed efficiently for any piece.
In Gaussian linear bandits, such a log-likelihood ratio is actually equivalent to a KL divergence (see Corollary C.6),
[Equation]
which in turn is a quadratic form weighted by the design matrix V t :
= (cid:80)
[Equation]
s
[Equation]
T k s .
Therefore, with greater generality, in rest of this section we shall focus on showing that inf λ ∈ Λ p ( i ) ∥ θ − λ ∥ 2 V N can be computed efficiently for any θ, λ ∈ M , piece Λ p ( i ) , and (positive-definite) matrix V N := (cid:80)
k ∈
[ K ] N k ϕ k ϕ Tk with N ∈ R K ≥ 0 .
In all cases, this will require minimizing quadratic forms over half-spaces.
B.1 Best-arm Identification
In BAI, the goal is to find the arm with largest mean.
The set of answers is therefore I =
[ K ] and the correct answer of θ ∈ M is i ⋆ ( θ ) =
arg max k ∈ [ K ] θ T ϕ k .
Decomposition into pieces For each i ∈
I , the set of alternatives Λ( i ) can be decomposed into half-spaces,
[Equation]
Therefore, we can take P ( i ) =
[ K ] \ { i } with P i
= K − 1 and Λ p ( i ) = { λ ∈ M : λ T ϕ p > λ T ϕ i } for p ∈
[ K ] \ { i } .
Closest alternatives Take any j, k ∈ [ K ] with j ̸ = k .
For linear problems, for any θ ∈ R d ,
[Equation]
if θ T ( ϕ k − ϕ
[Equation]
) ≥ 0 , otherwise .
For the special case of unstructured problem, for any θ ∈ R K ,
[Equation]
if θ T ( ϕ k − ϕ j ) ≥ 0 and N j + N k > 0 , otherwise .
Efficient implementation In BAI, for each answer (i.e., arm) i ∈ I , the piece indexes p ∈ P ( i ) are themselves answers (different than i ).
Implementing the elimination stopping rule in its general form requires storing and iterating over K ( K − 1) elements (all items in P ( i ) for each i ∈ I ).
However, much better implementations exist that require storing at most K elements (one for each answer).
Here we propose two such implementations: the first, for full elimination, is more statistically-efficient, while the second one (for selective elimination) is more computationally-efficient.
Full elimination (statistically-efficient implementation)
Due to the structure of the problem, whenever we eliminate one piece Λ p ( i ) , we actually know that the mean reward of arm p cannot be better than that of arm i .
In other words, p cannot be the right answer.
Therefore, we can maintain a list of active arms I t which is initialized as I 0 =
[ K ] and updated as
[Equation]
Then, we stop whenever |I t | = 1 and return the single arm left active.
Due to the inner maximization, this implementation requires performing |I
t − 1 | ( K − 1) minimizations over half-spaces at each step to check elimination.
Proposition B.1.
An algorithm using the statistically-efficient implementation above never discards pieces later than (and thus never stops later than) the full elimination rule of (5) almost surely.
Proof.
If the algorithm eliminates a piece Λ p ( i ) at time t with (5),
[Equation]
This implies that the elimination condition in the statistically efficient implementation triggers as well.
Selective elimination (computationally-efficient implementation)
An even simpler implementation is to check elimination, at each time t , only for pieces related to the empirical optimal arm i ⋆
( ˆ θ t ) .
That is, we update I t as
[Equation]
This requires linear (in K ) per-round memory and time complexity.
Moreover, checking this stopping rule is more time-efficient than the LLR one.
The latter requires to perform K − 1 tests at each step, while the elimination one only performs O ( |I t − 1 | ) tests at each round t , thus becoming faster as arms are eliminated.
Proposition B.2.
An algorithm using the computationally-efficient implementation above never discards pieces later than (and thus never stops later than)
the selective elimination rule almost surely.
Proof.
If the algorithm eliminates a piece of the empirical optimal arm at time t using the selective elimination rule, the arm corresponding to that piece is also eliminated from the set I t above.
B.2 Top-m Identification
In top- m identification
, the goal is to find the m > 0 arms with largest mean.
BAI is therefore a special case of this problem when m = 1 .
The set of answers is I =
{S ⊆
[ K ] : |S| = m } with size |I| = (cid:0)
Km (cid:1) and the correct answer of θ ∈ M is i ⋆ ( θ ) =
arg max mk ∈ [ K ] θ T ϕ k , where we use arg max m : R K (cid:55)→ (cid:0)
Km (cid:1) to denote the function returning the set of m largest values.
Decomposition into pieces Let us denote each i ∈
I as a tuple i =
( k 1 , . . .
, k m ) of m arms.
Similarly to BAI, it is known that the set of alternatives Λ( i ) can be decomposed into half-spaces [29],
[Equation]
Therefore, we have P ( i ) =
i × ([ K ] \ i ) with P i = m
( K − m ) and Λ p ( i ) = { λ ∈ M : λ T ϕ k > λ T ϕ j } when p = ( j, k ) .
Closest alternatives Note that each set Λ p ( i ) is still a half-space of the same form as the one we have for BAI.
Hence, the same closed form expression for the closest alternative derived for BAI can be adopted for top- m identification (see the closed-form expressions in the previous section).
Efficient implementation Note that, differently from BAI, here the set of answers is of combinatorial size.
It is therefore intractable to store and enumerate all sets of active pieces P t
( i ) .
However, thanks to the structure of the problem, this is not necessary and there exists an efficient implementation for the elimination stopping rule.
First note that, while there are m ( K − m ) pieces for each of
[Equation]
possible answers
, the total number of half-spaces is only K ( K − 1) , one for each couple of different arms.
With some abuse of notation, let us denote by Λ k,j :=
[Equation]
the half-space associated with arms k and j .
The elimination stopping rule, which checks whether all the pieces in P ( i ) for some answer i have been discarded, is equivalent to checking whether there exist m arms k 1 , . .
, k m such that Λ k,k l has been eliminated for all k / ∈ { k 1 , . . .
, k m } and l ∈ [ m ] .
Therefore, in our implementations we will only store whether each half-space Λ k,k l has been eliminated or not.
As before, we now see two possible implementations, one more computationally efficient and the other more statistically efficient.
Full elimination (statistically-efficient implementation)
The idea is to check, at each time step t , the elimination condition for all half-spaces which have not been previously discarded.
In particular, for each arm j ∈ [ K ] we keep a set S t ( j ) storing those arms which are “worse” than j .
Formally, we initially set S
( j ) = ∅ and update it as
[Equation]
λ ∈ Λ k [Equation] j L t (ˆ θ t
[Equation]
λ
[Equation]
t [Equation] (cid:111) if |S t − 1 ( j ) | < K − m,
S t − 1 ( j ) otherwise .
That is, when a half-space Λ k,j is eliminated, we conclude that arm k is “worse” than arm j and thus add the former to S t ( j ) .
In order to decide when to stop, we use the following intuition: whenever we find that |S t ( j ) | ≥ K − m for some arm j ∈
[ K ] , then we know that j must be in the top-m arms of θ and we can thus stop updating the set S t ( j ) .
Therefore, we can stop whenever there exist m arms satisfying this property.
This can be checked efficiently by keeping track of how many arms reach the condition |S t ( j ) | ≥ K − m and stopping when the number of such arms reaches m .
This approach takes O ( K ( K − m )) memory in the worst-case to store the sets S t ( j ) .
At each step, it performs exactly
[Equation]
check the elimination conditions, which gives O ( K ( K − 1)) time complexity in the worst-case.
Proposition B.3.
An algorithm using the statistically-efficient implementation above never discards pieces later than (and thus never stops later than) the full elimination rule of (5) almost surely.
Proof.
Note that the elimination condition for single half-spaces is exactly the same in the general elimination rule of (5) and in its implementation above.
If (5) eliminates a piece Λ p ( i ) at time t , this implies some half-space Λ k,j is eliminated.
Then, we have two possible cases: if |S t − 1 ( j ) | < K − m , then we have k ∈ S t ( j ) by the condition above, i.e., k is detected as “worse” than j and it will be never checked again.
On the other hand, if |S t − 1 ( j ) | ≥ K − m , then j has already been labeled as belonging to the final answers.
Thus, no minimization over its corresponding half-spaces (including the one for k ) will be checked anymore, which is the same as saying that Λ k,j has already been eliminated.
Selective elimination (computationally-efficient implementation)
Similarly to what we did for BAI, the most computationally-efficient implementation consists in checking the elimination condition only for the alternative pieces (i.e., the half-spaces) of the empirical correct answer at each step.
We modify the update rule of the statistically-efficient implementation as
[Equation]
if j ∈ i ⋆ (ˆ θ t ) and |S t − 1 ( j ) | <
K − m , and S t ( j ) :
= S t − 1 ( j ) .
That is, at each step we only check elimination for half-spaces associated with the top-m arms of ˆ θ t , excluding those that have already been eliminated and those that have already reached the threshold for being among the final answer.
Note that this implementation performs
[Equation]
m ( K − m ) minimizations over half-spaces at each step t .
In constrast, the LLR stopping rule always performs m ( K − m ) minimizations and is thus less efficient.
Proposition B.4.
An algorithm using the computationally-efficient implementation above never discards pieces later than (and thus never stops later than)
the selective elimination rule almost surely.
Proof.
The proof is the same as for BAI: if an arm is discarded by the selective elimination rule, then it is also discarded from the sets above.
B.3 Thresholding Bandits
In the thresholding bandit problem, the goal is to learn whether the mean of each arm is above or below some given threshold.
As usual, without loss of generality, we shall take zero as our threshold, for which the problem reduces to learning the sign of the mean reward of each arm.
Let sign( x ) :
= 1 ( x ≥ 0) .
Then, the set of answers is I = { 0 , 1 } K with size |I| =
2 K .
The correct answer of problem θ ∈ M is i ⋆ ( θ )
=
(sign( θ T ϕ k ))
k ∈ [ K ] .
Decomposition into pieces For each i ∈ { 0 , 1 } K (represented as a K -dimensional binary vector), the set of alternatives Λ( i ) can be decomposed into pieces as
[Equation]
Therefore, we have P ( i ) =
[ K ] with P i
=
K and Λ p ( i ) = { λ ∈ M : sign( λ T ϕ p ) ̸
= i p } .
As for
BAI, the computation of the closest alternative over such pieces can be performed efficiently.
Closest alternatives Let θ ∈ M and N ∈ R K ≥ 0 .
The computation of the closest alternatives over pieces Λ p ( i ) can be reduced to the following optimization problem.
For any arm k ∈ [ K ] and any b ∈ { 0 , 1 } , we need to find
[Equation]
It is easy to see that this is zero when b ̸ = sign( θ T ϕ k ) (since θ itself is feasible).
In case b = sign( θ T ϕ k ) , for unstructured problems ( M = R K ), the solution is to take λ equal to θ at all components except the k -th one, where it is set to zero.
This gives
[Equation]
In the linear case, again under the assumption that V N is positive definite, we get
[Equation]
Efficient implementation For this problem, implementing the general elimination stopping rule would require storing and iterating over 2 K K pieces, which is clearly intractable.
However, this problem introduces a high redundancy in the alternative pieces that we can exploit for an efficient implementation which takes only linear (in K ) time and space.
Differently from BAI and top-m identificaiton, the procedure highlighted below is exactly an implementation of the “theoretical” elimination rules presented in the main paper, with the full and selective elimination rules reducing to the same thing.
Note that, for any p ∈
[ K ] and i, j ∈ { 0 , 1 } K such that i p =
j p , we have Λ p ( i ) =
Λ p ( j ) .
That is, whenever we eliminate some piece Λ p ( i ) for p ∈
[ K ] and i ∈ { 0 , 1 } K , we actually eliminate all problems in M whose sign of the p -th mean reward is different from i p .
In other words, we learn that the p -th position of the correct answer for θ is indeed i p .
Therefore, an efficient implementation is as follows: we keep a set
A t of active arms (those for which we still have to learn the corresponding component in the correct answer).
This set is initialized as A 0 =
[ K ] and updated as
[Equation]
While the maximization over 2 K elements might appear intractable, the structure of the problem allows us to entirely avoid it.
Note that, for fixed j , the sets Λ j ( i ) are fully specified by the j -th component of i .
Moreover, the inf is zero whenever i j ̸ = sign(ˆ θ Tt ϕ j ) since that would imply ˆ θ t ∈ Λ j ( i ) .
Therefore, the elimination condition can be equivalently rewritten in the convenient form
[Equation]
Moreover, whenever the elimination condition above triggers for some arm j ∈ [ K ] , we set a variable
S j :=
sign(ˆ θ Tt ϕ j ) with the correct sign for the j -th component.
We stop whenever A t = ∅ (i.e., when all signs have been learned) and return ˆ i :=
( S 1 , S 2 , . . .
, S K ) .
Similarly to BAI, this requires to perform only |A t − 1 | tests at each step t .
On the other hand, the LLR stopping rule would perform
K tests at each step.
C Log-likelihood ratio in exponential families
We suppose in this section that all arms have distributions in a one-parameter exponential family (the same for all arms, for simpler notations).
An arm distribution can thus be described by any one of three parameters: the arm feature vector ϕ k ∈ R d , the arm mean µ k ( θ ) =
ϕ ⊤ k θ and its natural parameter η k ( θ ) .
These two last are functions of the model θ .
For two models θ and λ , let f be a function such that the KL between the arm distributions with those parameters is d f ( η k ( λ ) , η k ( θ )) , where d f is the Bregman divergence associated to f .
Let f ∗ be the convex conjugate of f .
The
Kullback-Leibler divergence between the arm distributions under models θ and λ is also equal to d f ∗ ( µ k ( θ ) , µ k ( λ )) .
If η k ( θ ) is the natural parameter of that arm k , we have µ k ( θ )
= f ′ ( η k ( θ )) , and since ( f ∗ ) ′ =
( f ′ )
−we have η k ( θ ) =
( f ∗ ) ′
( µ k ( θ )) .
Lemma C.1.
For all θ, λ ∈ M , the quantity L t ( θ, λ ) − (cid:80)
Kk =1 N kt KL k ( θ, λ ) is a martingale if the observations come from the model θ .
This does not depend on the hypothesis that the distributions belong to an exponential family but only requires P θ ≪ P λ .
Proof.
We can expand the LLR to obtain a sum over times and write the KL as an expected loglikelihood ratio,
[Equation]
The martingale property is then immediate.
Many of our proofs depend on the informal statement that the martingale L t ( θ, λ ) −
[Equation]
Kk =
[Equation]
N kt KL k ( θ, λ ) concentrates, and is thus a lower order term which is negligible for t large enough.
Lemma C.2.
For all θ, λ and all X [ t ] ,
[Equation]
Proof.
Write log d P θ d P λ ( X ) =
η ( θ ) X − f ( η ( θ )) − ( η ( λ ) X − f ( η ( λ ))) and develop the Bregman divergence (the KL) on the right.
Lemma C.3.
If the distribution of arm k for model θ is σ 2 -sub-Gaussian, then for all λ ,
[Equation]
Proof.
We first prove that the sub-Gaussian hypothesis is equivalent to both these inequalities:
[Equation]
The first result is then a simple consequence of that second inequality and the equality KL( λ, θ ) =
d f ∗ ( µ k ( λ ) , µ k ( θ )) .
The second result of the lemma can be obtained by applying the first one to λ
=
ˆ θ t for all arms, then summing over arms.
The cumulant generating function at parameter η k ( θ ) is ξ (cid:55)→ d f ( η k ( θ )+ ξ, η k ( θ )) .
The sub-Gaussian hypothesis is that this function is lower than 12 σ 2 ξ 2 .
For the second inequality, we first remark that the convex conjugate of ξ (cid:55)→ d f ( η k ( θ ) + ξ, η k ( θ )) is x
(cid:55)→ d f ∗ ( µ k ( θ ) + x, µ k ( θ )) , and write
[Equation]
Corollary C.4.
If the distribution of arm k for model θ is σ 2 -sub-Gaussian, then for all λ ,
[Equation]
Remark: for Gaussians with variance σ 2 , we also have
[Equation]
Kk =
[Equation]
N kt KL k ( θ, λ ) .
But that is not the case in general, and the sub-Gaussian assumption tells us that the sum of squares is larger than a KL, while we would like the reverse inequality.
Proof.
Apply the Cauchy-Schwarz inequality, then Lemma C.3:
[Equation]
K
[Equation]
C.1 Log-likelihood ratio for Gaussian linear models
Lemma C.5.
For any θ ∈ M and k ∈ [ K ] , let ν k ( θ ) be Gaussian with unit variance and linear mean µ k ( θ )
= θ
T ϕ k .
Then for any θ, λ ∈ M , any t > 0 and any sequence of observations,
[Equation]
Proof.
Apply Lemma C
[Equation]
2 to the Gaussian case
[Equation]
where η ( θ )
= µ ( θ ) =
ϕ ⊤ k θ .
[Equation]
For Gaussian linear models, we have
K
[Equation]
We can use this to replace the sum involving ˆ µ t,k in the expression of L t ( θ, λ ) by one involving ˆ θ t .
[Equation]
t
[Equation]
Corollary C.6.
For the linear Gaussian model of Lemma C.5, for any λ ∈ M ,
[Equation]
Lemma C.7.
For any θ ∈ M and k ∈ [ K ] , let ν k ( θ ) be Gaussian with unit variance and linear mean µ k ( θ )
= θ
T ϕ k .
Then, for any λ ∈ M and t > 0 , 
[Equation]
k ∈ [ K ]
[Equation]
Proof.
We decompose the LLR as
[Equation]
The second term is bounded by Corollary C.4 (with σ 2 = 1 ) and the remark below it.
We get
[Equation]
The proof of the lower bound is similar
[Equation]
C.2 Beyond Gaussians
While the proofs in the next two sections are specialized to Gaussian rewards
[Equation]
it is possible to extend them to more exponential families under slight assumptions
[Equation]
similarly to what was done in [15]
[Equation]
If the arm distributions are known to belong to a σ 2 -sub-Gaussian exponential family
[Equation]
with the additional restriction that the distribution parameters should belong to a compact subset of the open interval on which the family is defined
[Equation]
then there exists a constant c such that
[Equation]
And (cid:80)
[Equation]
=1 N kt KL k ( θ, λ ) is also close to ∥ λ − θ ∥ 2 V t , up to constant factors.
We can then recover bounds on the likelihood ratio of the same shape as in Lemma C.7, up to constant factors depending on c and σ 2 .
The proofs of Appendix D and Appendix E then proceed similarly, up to the additional constants.
D Proofs of SectionD.1 Proof of Lemma 2.
Proof.
Fix any θ ∈ M and let ˆ i be the answer returned by the algorithm at the stopping time τ .
Then,
[Equation]
where (a) is from the definition of stopping rule, (b) is from the fact that, if P τ ( i ) is empty, then all the pieces of i have been eliminated at some times before τ , and (c) follows trivially by relaxing the condition t ≤ τ to t ≥ 1 .
Take any t ≥ 1 .
Now note that, for any wrong answer i ̸
= i ⋆ ( θ ) , θ ∈ Λ( i ) .
By definition of the decomposition into pieces of Λ( i ) , this means that there exists ¯ p i ∈ P ( i ) such that θ ∈ Λ ¯ p
i
( i ) .
Therefore, continuing the chain of inequalities above, we get that
[Equation]
where (d) holds since the event under which all pieces for i have been eliminated implies that ¯ p i has been eliminated as well, (e) holds since θ ∈ Λ ¯ p
i ( i ) , and (f) is from the assumption on threshold β t,δ .
This concludes the proof.
D.2 Proof of Theorem 2.
Theorem 2.4 was proved in the main text.
We prove here a more general result about the monotonicity of the stopping time with respect to the piece decomposition.
We show that if two algorithms use the same sampling rules and use elimination stopping based on different piece decompositions, the algorithm using the finer decomposition (in the sense defined below) will stop earlier.
Definition D.1.
We say that a piece decomposition (Λ p ( i ))
i ∈I ,p ∈P ( i ) is finer than another one (˜Λ p ( i ))
i ∈I ,p ∈ ˜
P
( i ) if for all i ∈
I , p ∈ ˜
P
( i ) , there exists a set S
⊆ P ( i ) such that ˜Λ p ( i ) =
(cid:83) q
[Equation]
S
[Equation]
Theorem D.2.
Let D =
(Λ p ( i ))
i ∈I ,p ∈P ( i ) be a finer decomposition than ˜ D = (˜Λ p ( i ))
i ∈I ,p ∈ ˜
P
( i ) .
For i ∈ I , ˜
p ∈ ˜ P ( i ) , let τ ˜ p
and
˜ τ
˜ p be the times at which ˜Λ ˜ p ( i ) is eliminated by the two corresponding algorithms (in the sense of Definition 2.2).
Then almost surely τ ˜ p ≤ ˜ τ ˜ p .
Roughly, if a piece in the tilde decomposition corresponds to several pieces in the other, then it is faster to eliminate it as several pieces than as one piece.
Proof.
It is enough to prove that whenever the elimination stopping rule of ˜Λ ˜ p ( i ) triggers for ˜ D , it triggers for D too.
Then, let t ≥ 1 and suppose that
[Equation]
Let S ˜ p
⊆
P ( i ) be the set corresponding to ˜ p in the definition of “finer decomposition”.
We first argue that
[Equation]
Indeed, this is simply writing the infimum over a union as the infimum of an infimum.
Hence if the ˜ p piece is eliminated in ˜ D , we have
[Equation]
and every piece Λ p ( i ) for p ∈ S
˜ p is eliminated as well in D .
We get that the set ˜Λ ˜ p is also eliminated in D .
Corollary: the finest possible decomposition is the one in which P ( i ) =
Λ( i ) and Λ p ( i ) =
{ p } , i.e. every point of Λ( i ) is its own piece.
This is not a computationally usable decomposition, but its the theoretically best one for the sample complexity metric (for a fixed sampling rule).
Theorem 2.4 for full elimination compared to LLR stopping follows from Theorem D.2 by setting ˜
P ( i ) = { 0 } and ˜Λ p ( i ) =
Λ( i ) .
Then the elimination stopping rule uses a finer decomposition than the LLR stopping rule.
D.3 Proof of Theorem 2.
We first present two important lemmas which will be used to prove the main statement for full elimination and selective elimination, respectively.
For full elimination, the following lemma shows that if a piece has not been eliminated the information collected by the algorithm about it must be small.
Lemma D.3.
Consider an algorithm that uses the full elimination stopping rule (5) .
Let p ∈ P
( i ⋆ ( θ )) , then, for each time t such that E t (Equation 6) holds and
p ∈ P t ( i ⋆ ( θ )) ,
[Equation]
On the other hand, if the algorithm uses the LLR stopping rule, for each time t such that E t holds and the algorithm did not stop,
[Equation]
(cid:113) β t, 1 /t 2 .
Proof.
Since p ∈ P t ( i ⋆ ( θ ))
(i.e., p has not been eliminated at time t ), we have from (5) and Lemma
C.7 that
[Equation]
By definition of event E t , this implies
[Equation]
This yields the first statement.
The second result can be shown analogously by using the full set of alternatives to θ .
Selective elimination updates, at each step t , only the set of active pieces of the empirical answer i ⋆ (ˆ θ t ) .
Therefore, to bound the elimination times of the pieces Λ p ( i ⋆ ) for p ∈ P ( i ⋆ ) we need to show that i ⋆ (ˆ θ t ) ̸
= i ⋆ after a certain time.
We show that Assumption 2.5 alone is sufficient to guarantee this.
Lemma D.4.
Consider a sampling rule satisfying Assumption 2.5.
Under event E t , a sufficient condition for i ⋆ (ˆ θ t ) =
i ⋆ is
[Equation]
Proof.
First note that, under E t , if
[Equation]
then i ⋆ (ˆ θ t )
= i ⋆ .
In fact, if this was not the case, we would have θ ∈ Λ( i ⋆ (ˆ θ t )) and thus L t (ˆ θ t , θ ) > β t, 1 /t 2 , which is a contradiction with event E t itself.
Let us now look for a sufficient condition on t to satisfy this inequality.
Take t and suppose it does not satisfy it.
Then,
[Equation]
where (a) is from Lemma C.7, (b) from E t and the fact that either i ⋆ (ˆ θ t )
=
i ⋆ or the infimum is zero, and (c) from Assumption 2.5.
Rearranging this inequality yields the desired condition on t .
Proof of Theorem 2.6.
We start by proving the sample complexity bound for LLR stopping.
Since it is a bound on the elimination time of the whole alternative Λ( i ⋆ ) , by definition it also holds for the elimination times of its pieces obtained with either full or selective elimination.
We then move to full elimination stopping and selective elimination stopping.
Finally, we prove that the left-hand side of the maximum in (15) is never larger than the bound for LLR stopping.
LLR stopping Let t > 0 such that E t holds and the algorithm did not stop.
The second statement in Lemma D.3 yields
[Equation]
Moreover, from Assumption 2.
[Equation]
The combination of these two inequalities directly yields the stated inequality on t .
The result in expectation is obtained by applying Lemma 19 in [29] together with P ( ¬ E t ) ≤ 1 /t 2 .
Full elimination stopping Let t > 0 such that E t holds.
By Assumption 2.5,
[Equation]
This implies that N t t ∈ Ω R ( θ,t ) /t .
Now fix a piece p ∈ P ( i ⋆ )
such that p ∈ P t ( i ⋆ ) .
Under event E t , we know from Lemma D.
that
[Equation]
Since N t t ∈ Ω R ( θ,t ) /t ,
[Equation]
Combining the last two displays, we obtain that, if j is not eliminated at time t and E t holds, t itself must satisfy
[Equation]
The result in expectation is obtained by applying Lemma 19 in [29] together with P ( ¬ E t ) ≤ 1 /t 2 .
Selective elimination stopping Given Lemma D.4, the proof of Theorem 2.6 for elimination stopping is very simple.
Simply take a time t such that E t holds and which verifies the condition in
Lemma D.4.
Then, for such a t the first claim of Lemma D.3 can be verified analogously since the empirical answer (the one for which the set of active pieces is updated) is exactly the correct answer.
Given Lemma D.3, the same derivation as in the proof for full elimination can be carried out.
This yields the following sufficient condition on the time t to eliminate a piece p ∈ P ( i ⋆ ) :
[Equation]
Comparison of the bounds for full elimination and LLR stopping We finally prove that a sufficient condition for t ≥ ¯ t p , with ¯ t p associated to full elimination, is t ≥ ¯ t .
Take any p ∈ P ( i ⋆ ) .
By definition of the set Ω ϵ , we have that, for any ω ∈ Ω ϵ ,
[Equation]
This implies that
[Equation]
A sufficient condition for satisfying the inequality for piece elimination is thus
[Equation]
Let γ ∈ (0 , 1) .
For R ( θ, t ) /t ≤ γH
⋆ ( θ ) we have that
[Equation]
suffices.
Therefore, taking the maximum between the condition above and t ≥ R ( θ,t ) γH
⋆ ( θ ) and optimizing over γ ∈ (0 , 1) , the inequality for piece elimination is verified if
[Equation]
Optimizing over γ , which amounts to setting γ =
R
[Equation]
, yields the desired statement.
D.4 Proof of Theorem 2.
Proof.
Take any time t and suppose that E t holds while the algorithm did not stop with τ llr yet.
Using the first result of Theorem 2.6 yields
[Equation]
From Lemma 19 in [29], we get that E [ τ llr ] ≤ ¯ t + 2 , where ¯ t is the first time that does not satisfy the inequality above (it is a function of θ and δ ).
This means that
[Equation]
Now let us take the same algorithm with τ elim .
We know it is δ -correct, so the standard lower bound states that
[Equation]
We get that
[Equation] [Equation]
We now use the hypothesis β ¯ t,δ = log 1 δ + ξ (¯ t, δ ) :
[Equation]
E Proofs of Section
In order to tune our resets, we need an hypothesis on the shape of the threshold, used to compare thresholds at different times.
Assumption E.1.
There exist two positive reals c 1 and c 2 that may depend on the parameters of the problem known to the algorithm ( d , K , etc.) and a function log such that the threshold β t,δ verifies
[Equation]
Furthermore, log verifies that there exists x 0 such that for all a ≥ 2 and x ≥ x 0 , log( x a ) ≤ a log( x ) .
The function log represents an almost logarithmic function and corresponds to the function of order log + √ log in [25] or log + d log log in [30, 29].
Other thresholds have a O (log log( t )) dependence instead of O (log( t )) , and our analysis could be extended to them in a similar way.
With that assumption, we set
[Equation]
and
[Equation]
The reset times we defined are taylored to a threshold β t,δ of order log(1 /δ )
+ O (log( t ))
as in
Assumption E.1.
They are chosen such that β t, 1 /t 2 roughly doubles from one reset to the next.
If the thresold has a different dependence in t (for example O (log log t ) ) then the reset times can be adapted.
E.1 On Assumption E.
We illustrate first how Assumption E.1 covers the threshold obtained by the most common technique: first get a concentration bound valid for one time of the form f (1 /δ ) , where usually f ( x ) = log( x ) +
C log log( x ) (for C a dimension-dependent constant), then obtain a time-uniform concentration threshold by setting for example β t,δ = f
( π 2 t 2 6 δ ) .
Let us suppose then that β t,δ = f ( C ′ t 2 δ ) for f ( x )
= log( x ) + C log log( x ) and C ′ ≥ 1 .
We will now prove that if verifies Assumption E.1.
[Equation]
where log( x ) = log( C ′ x ) + C log log( C ′ x ) .
Using the concavity of log , we also have an upper bound
[Equation]
We have found a function log such that for c 1 = 2 and c 2 = 2( C + 1) ,
[Equation]
t
[Equation]
It remains to show the condition on log , i.e. find x 0 such that for a ≥ 2 and x ≥ x 0 , log( x a ) ≤ a log( x ) .
[Equation]
It remains to find x 0 such that for x ≥ x 0 , log log( C ′ x ) + log a ≤ a log log( C ′ x ) .
We find that x 0 = exp( a 1 / ( a − 1) ) /C
′ is suitable.
Since a ≥ 2 , we have x 0 ≤ e 2 /C ′ .
Lemma E.2.
Under Assumption E.1, for any time t and 0 ≤ j ≤ j ( t ) ,
[Equation]
Proof.
We have ¯ t 0 = max { 2 , √ x 0 } .
Note that for all j , ¯ t j = ¯ t 2 j 0 .
By using first the upper bound of
Assumption E.1, then t ≤ ¯ t 2 j ( t )
+1and at the end the lower bound of Assumption E.1, β t,
[Equation]
log
[Equation]
We have t j ≥ ¯ t 0 ≥ √ x 0 , hence the inequality log( x a ) ≤ a log( x ) can be used.
Then
[Equation]
E.2 Proof of Theorem 3.
We now derive an important result for sampling rules combined with elimination (either full or selective).
It essentially shows that we cannot eliminate the closest alternative piece to θ from the sampling rule without making the algorithm stop.
Lemma E.3.
Let t ≥ ¯ t 1 be any time step at which the algorithm did not stop.
Suppose that some piece index p ∈ P ( i ⋆ ) of the true correct answer i ⋆ has been eliminated from the sampling rule (i.e., p / ∈ P smp t ( i ⋆ ) ).
Then, under event E t (see Equation 6),
[Equation]
Proof.
Let us proceed by contradiction: suppose that
[Equation]
while
[Equation]
holds
[Equation]
Since P smp t ( i ⋆ ) is the intersection of all active sets from t j ( t ) − 1 to t , if p / ∈ P smp t ( i ⋆ ) , then there exists s with t j ( t ) − 1 ≤ s ≤ t such that
[Equation]
Therefore,
[Equation]
where (a) is from the elimination condition, (b) uses Lemma C.7, (c) uses that E t holds, (d) uses that the number of pulls of each arm is non-decreasing in time, and (e) holds by our assumption.
Recall that, for any θ, λ ∈ R d ,
[Equation]
Therefore, by the triangle inequality,
[Equation]
Combining this with the previous chain of inequalities,
[Equation]
where we used again that E t holds to concentrate the LLR between ˆ θ t and θ .
The last inequality is easy to check since, if i ⋆ ̸
= i ⋆ (ˆ θ t ) , then inf λ ∈ Λ( i ⋆ )
L t (ˆ θ t , λ ) = 0 .
Finally, since the algorithm did not stop at t , it must be that inf λ ∈ Λ( i ⋆ )
L t (ˆ θ t , λ ) <
β t,δ (otherwise all alternative pieces of i ⋆ (ˆ θ t ) would be eliminated at t ).
Therefore,
[Equation]
Since s ≥ t j ( t ) − 1 , from Lemma E.2 we have that
[Equation]
Plugging this into our previous bound, we conclude that
[Equation]
This is clearly a contradiction w.r.t.
our definition of α t,δ .
Proof of Theorem 3.2.
Take any step t ≥ ¯ t 1 where E t holds.
Lemma E
[Equation]
3 ensures that all pieces of i ⋆ which are at minimal distance from θ , i
[Equation]
e., such that
[Equation]
are not eliminated for the sampling rule at time t , i
[Equation]
e., p ∈ P smp t ( i ⋆ ) .
This implies that
[Equation]
Thus, if Assumption 3.1 holds, it must be that
[Equation]
where the second inequality is trivial from P smp s − 1 ( i ⋆ )
⊆
P ( i ⋆ ) for all s ≥ 1 .
Therefore, we proved that the condition of Assumption 2.5 holds as well for all t ≥ ¯ t 1 .
We can now have it for all t by adding ¯ t 1 H ⋆ ( θ ) to R ( θ, t ) to obtain another regret function which verifies the condition of Assumption 2.5.
The second statement is a direct consequence of the fact that Theorem 2.6 holds for any sampling rule that satisifes the latter assumption.
F Existing Algorithms Satisfy Assumption 2.5 and 3.
In this section, we show that existing sampling rules that target the optimal value of the max-inf game from the general lower bound of [31] satisfy Assumption 2.5.
Moreover, we show that, when such sampling rules are combined with elimination (as in Section 3), they also satisfy Assumption 3.1.
We do that explicitly for two algorithms: the game-theoretic approach based on no-regret learners of [15] and an optimistic variant of the Track-and-Stop algorithm of [31].
These two algorithms are sufficiently general to be representative of many existing approaches for pure exploration: the latter represents those that repeatedly solve the optimization problem from the lower bound to get optimal allocations, while the former represents those that solve such problem incrementally.
We now describe these two algorithmic techniques.
Then, we show, through a unified proof, that they satisfy Assumption 2.5 and 3.1.
F.1 Sampling Rules
We describe the sampling rules of interest while trying to keep some of their design choices (e.g., confidence intervals, tracking, optimization, etc.)
as general as possible.
We do this because these sampling rules have been adapted to different pure exploration problems and bandit structures in the literature, for which such components would be different.
This will allow us to have unified proofs that are actually agnostic to the specific setting.
F.2 Common Assumptions
We first state some assumptions on the main common components of these algorithms.
Bounded closest alternatives First, we shall make a mild regularity assumption about the considered identification problem: the distance between any closest alternative and θ is bounded.
Assumption F.1.
There exists a constant B > 0 such that, for any ω ∈ R ≥ 0 and any subset Λ ⊆ M which is exactly the union of arbitrary pieces, there exists a closest alternative
[Equation]
such that
[Equation]
We note that this assumption is satisfied in the identification problems we consider (see Appendix B), for Gaussian rewards where pieces are half-spaces.
Tracking All the sampling rules we consider choose a sequence of proportions ( ω t ) t ≥ 1 , where ω t ∈ ∆ K , and use tracking to select the next arm to play based on these.
Formally, the arm played at time t is
[Equation]
where Track : R K + × R K + → [ K ] is some tracking function.
To gain generality, we shall keep the tracking function implicit in the remainder, while only requiring the following assumption (which is actually guaranteed by existing methods).
Assumption F.2.
There exists a constant C track > 0 such that
[Equation]
For instance, the widely-adopted cumulative tracking,
[Equation]
satisfies this assumption.
Confidence intervals These sampling rules maintain confidence intervals ( c kt ) t ≥ 1 ,k ∈
[ K ] about the expected return of each arm.
We shall also keep them implicit as their specific form depends on the bandit structure under consideration (e.g., linear vs unstructured).
We will only require the following assumption, which is satisfied by common choices as described below.
Assumption F.3.
Under event E t ,
[Equation]
Moreover, there exists a sub-linear (in t ) function C conf ( t ) such that
[Equation]
In bandits with linear structure, the confidence intervals typically take the form c kt ∝ ∥ ϕ k
∥ V − 1 t .
In this case finding an upper bound on
[Equation]
[ K ] ω ks c ks − 1 would reduce to applying an elliptical potential lemma [25] plus the tracking property, and the resulting upper bound would be C conf ( t )
∝ √ dt .
In unstructured bandits we can take c kt ∝ 1 / (cid:112)
N kt and finding C conf ( t ) would require applying the standard pigeon-hole principle plus the tracking property, for which one obtains C conf ( t ) ∝ √ Kt .
F.2.1 Optimistic Track-and-Stop
Here we describe an optimistic variant of the Track-and-Stop algorithm by [31].
It was originally introduced by [15] in order to get rid of forced exploration, one of the main causes behind the poor empirical performance of Track-and-Stop.
The idea is to solve, at each time step t , an optimistic variant of the optimization problem from the lower bound,
[Equation]
where c kt − 1 is a per-arm confidence interval that satisfies Assumption F.3, thus ensuring optimism
KL k (ˆ θ t − 1 , λ ) + c kt − 1 ≥ KL k
( θ, λ ) with high probability.
The solution to this optimization problem yields proportions ω t which are tracked by the sampling rule.
Then, the arm played at time t is given by the tracking rule (11).
Combining with elimination In order to combine this sampling rule with elimination, we simply redefine the optimization problem as
[Equation]
That is, we simply replace a minimization over the whole alternative with one over the active pieces only.
F.2.2 Game-Theoretic Approach with No-Regret Learners
The idea behind the game-theoretic approach of [15] is to avoid recomputing the full optimistic problem (12) at each step, while solving it incrementally by means of no-regret learners.
Given some online-learning algorithm L working on the K -dimensional simplex, the sampling rule works as follows.
At each time t , first L outputs new proportions ω t .
Then, we compute the closest alternative
[Equation]
Finally, L is updated with the (concave) gain function
[Equation]
Finally, the sampling rule uses tracking exactly as in (11) to decide the next arm to pull.
As before, we will only require the tracking rule to satisfy Assumption F.2 without specifying an explicit form.
Similarly, we will keep the learner implicit as far as it satisfies the following no-regret property.
Assumption F.4.
The learner L is no regret: there exists a sub-linear (in t ) function C L ( t ) such that, for any t ≥ 1 and any sequence of gains { g s ( ω ) } s ≤ t ,
[Equation]
Combining with elimination For the game-theoretic approach, we only need to redefine the closest alternative used in the gains as
[Equation]
F.3 Assumption 2.5 Holds
We need to show that, for any time t ≥ 1 where the good event E t (Equation 6) holds, the two sampling rules presented above satisfy
[Equation]
for suitable choices of the function R ( θ, t ) .
We shall write a unified proof for these two sampling rules while explicitly mentioning where they differ.
Let us suppose that their algorithmic components satisfy the assumptions stated above, i.e., Assumption F.2 for tracking, Assumption F.3 for the confidence intervals, and Assumption F.4 for the no-regret learner.
Take any time step t ≥ and suppose that
E t holds.
Let λ t :=
[Equation]
Then, using the tracking property (Assumption F.2) together with Assumption F.1,
[Equation]
We can now lower bound the first term as
[Equation]
where (a) is from the concavity of the infimum, (b) holds since either Λ( i ⋆ (ˆ θ s − 1 ))
=
Λ( i ⋆ ) or θ ∈ Λ
( i ⋆ (ˆ θ s − 1 ))
(in which case the infimum would be zero), (c) is from the validity of the confidence intervals under E t , and (d) is from Assumption F.3.
Now note that, when applying the game-theoretic approach (Section F.2.2), the first term on the right-hand side is exactly the sum of gains fed into the learner.
Thus, using the no-regret property (Assumption F.4),
[Equation]
If instead we are applying optimistic Track-and-Stop (Section F.2.1), the first term on the right-hand side is exactly the sum of optimal values of the objective functions maximized by the algorithm.
Thus,
[Equation]
Therefore
[Equation]
we only need to lower bound the first term above, which is common between the two considered algorithms.
We have
[Equation]
where (e) follows from the same reasoning as step (b) above
[Equation]
(f) is from the fact that confidence intervals are valid under E t , and (g) is from the definition of the game in the lower bound.
Putting all together, we proved that optimistic Track-and-Stop satisfies Assumption 2.5 with
[Equation]
, while the game-theoretic approach satisfies it with
[Equation]
F.4 Assumption 3.1 Holds
We now show that Assumption 3.1 holds for these sampling rules combined with elimination as formally explained above.
The main steps are very similar as before, with the additional complications posed by eliminating pieces at sampling.
Recall that we want to show that, for any time t ≥ 1 where the good event E t (Equation 6) holds, the two sampling rules presented above satisfy
[Equation]
for suitable choices of the function R ( θ, t ) .
Take any time step t ≥ 1 and suppose that E t holds.
Let
[Equation]
be the closest piece and alternative at time t .
Then, using the tracking property (Assumption F.2) and
Assumption F.1,
[Equation]
Recall that t j :=
¯ t 2 j 0 is the time step at which the j -th reset is performed and j ( t ) :=
⌊ log 2 log ¯ t 0 t ⌋ is the index of the last reset before t .
Let ¯ t :=
t j ( t ) − 1 be the time of the second-last reset before t .
Note that
[Equation]
We can now lower bound the first term as
[Equation]
[Table]
infimum
Now note that, when applying the game-theoretic approach (Section F.2.2), the first term on the right-hand side is exactly the sum of gains fed into the learner.
Thus, using the no-regret property
(Assumption F.4),
[Equation]
If instead we are applying optimistic Track-and-Stop (Section F.2.1), the first term on the right-hand side is exactly the sum of optimal values of the objective functions maximized by the algorithm.
Thus,
[Equation]
Therefore
[Equation]
we only need to lower bound the first term above
[Equation]
which is common between the two considered algorithms.
We have
[Equation]
where (g) drops the first ¯ t rounds, (h) uses Lemma F.7, (i) is from the fact that confidence intervals are valid under E t , and (j) adds the missing first ¯ t rounds.
Putting all together, we proved that optimistic
Track-and-Stop satisfies Assumption 2.5 with
[Equation]
while the game-theoretic approach satisfies it with
[Equation]
Lemma F.5.
Under event E t , for any s ∈ N with t j ( t ) − 1 ≤ s ≤ t ,
[Equation]
Moreover, for any s, s ′ ∈ N with t j ( t ) − 1 ≤ s ′ ≤ s ≤ t ,
[Equation]
<
[Equation]
Proof.
Using the good event E t followed by an application of Lemma E.2 together with s ≥ t j ( t ) − 1 ,
[Equation]
This proves the first claim.
To prove the second one, note that
[Equation]
where (a) is from Corollary C.6, (b) is from the triangle inequality (recall that the sum of KLs is a norm), (c) is from the fact that the pull counts are non-decreasing and s ≥ s ′ , (d) is again from Corollary C.6, and (e) is from event E t .
Using Lemma E.2 as before, we have
[Equation]
This proves the second statement.
Lemma F.6.
Under event E t , for any i ∈ I and ω ∈ ∆ K ,
[Equation]
Proof.
The statement follows trivially if i = i ⋆ .
So suppose i ̸
= i ⋆ .
Since i is not the answer of θ , by the union property of the decomposition into pieces, there exists p ∈ P ( i ) such that θ ∈ Λ p ( i ) .
By
Lemma F.5, for any t j ( t ) − 1 ≤ s ≤ t ,
[Equation]
This implies that p ∈ P smp t ( i ) since such set is defined as the intersection of all active sets from t j ( t ) − 1 to t .
Finally, we conclude that
[Equation]
and thus our result follows trivially.
Lemma F.7.
Under event E t , for any t j ( t ) − 1 ≤ s ≤ t , i ∈ I , and ω ∈ ∆ K ,
[Equation]
Proof.
The proof is very similar to the one of Lemma F.6.
The statement follows trivially if i = i ⋆
(ˆ θ s ) .
So suppose i ̸
= i ⋆
(ˆ θ s ) .
Since i is not the answer of ˆ θ s , by the union property of the decomposition into pieces, there exists p ∈ P ( i ) such that ˆ θ s ∈ Λ p ( i ) .
By Lemma F.5, for any t j ( t ) − 1 ≤ s ′ ≤ s ≤ t ,
[Equation]
This implies that p ∈ P smp s ( i ) since such set is defined as the intersection of all active sets from t j ( t ) − 1 to s .
Therefore, we conclude that
[Equation]
and thus our result follows trivially.
G Experiment Details and Additional Results G.1 Reproducibility details
We provide the main details to reproduce our experiments.
For all the details, we refer the reader to our implementation at https://github.com/AndreaTirinzoni/bandit-elimination .
In all experiments, we used δ = 0 .
01 and a heuristic threshold β t,δ = log(1 /δ )
+ log(1 + t ) for all elimination rules and LLR stopping.
This is slightly larger than the heuristic threshold proposed by [4] and adopted in many recent works.
We implemented the elimination rules as described in
Appendix B. When using elimination at both stopping and sampling, we maintained only one set of active pieces (the one for stopping) instead of keeping a separate set with very lazy resets for sampling as suggested by theory.
That set is shared by both sampling and stopping rules, and is never reset.
Computational infrastructure All experiments were run on a Dell XPS 13 laptop with an Intel
Core i7-7560U (2.40GHz) CPU and 8GB of RAM.
G.2 Bandit instances
We provide details on how we generated the bandit instances considered in the experiments presented in the main paper and later in this section.
Linear instances (experiments of Figure 2 and Table 3)
We set K = 50 and d = 10 .
The true parameter is θ =
, 1] T , while we generated the arm features randomly.
The arm feature of the first arm is ϕ 1 =
. , 0] T .
Then, up to reaching 50 arms, we repeated the following procedure.
First, we generated a 3-dimensional vector v ∈ R 3 by drawing its elements uniformly in [ − 1 , 1]and then normalizing to have unit norm.
Then, we added 3 feature vectors v 1 = [0 , v, 0 , 0 , 0 , 0 , 0 , 0] , v 2 =
[0 , 0 , 0 , 0 , v, 0 , 0 , 0] , and v 3 =
[0 , 0 , 0 , 0 , 0 , 0 , 0 , v ] , but only if v T 1 θ ∈ [0 , 0 . 8] .
In this way, we obtain linear instances with 50 arms where arm 1 is optimal with value µ 1 ( θ ) = 1 , while all other arms have minimum sub-optimality of 0 .
2 and maximum sub-optimality gap of 0 . 8 .
Linear instances (experiments of Table 1)
We set K = 50 and d = 20 .
The first 10 arms are set to the canonical basis of R 10 , i.e., ϕ k
= e k for k = 1 , . . .
The generation of the true parameter θ and of the remaining 40 arms is slightly different from BAI/Top-m and OSI.
For BAI and Top-m, the true parameter θ has the first element equal to 1 , elements from the second to the fifth equal to 0 .
9 , and elements from the sixth to the tenth equal to 0 .
The remainingelements are uniformly drawn in [ − 0 .
The remaining 40 arms are randomly generated as follows.
First, we draw a vector v uniformly in [ − 1 , 1] 20 and normalize it to have unit norm.
Then, if v T θ ≤ 0 .
5 , we add v to the set of arms.
Otherwise, we reject the vector and keep repeating this procedure until we reach a total of 50 arms.
In this way, we obtain random linear instances where the first arm is optimal with value µ 1 ( θ )
= 1 , the next 9 arms are hard to discriminate from it since they have small gap (either 0 .
1 or 0 . 2 ), and all remaining 40 arms have moderate to large gap (at least 0 . 5 ) and are thus easy to eliminate.
For OSI, the true parameter θ has the first ten elements uniformly drawn in ([ − 0 .
2 , − 0 .
1] ∪ [0 . 1 , 0 .
2])and the second ten elements uniformly drawn in [ − 0 .
Similarly as before, to generate the remaining 40 arms we first draw a vector v uniformly in [ − 1 , 1] 20 and normalize it to have unit norm.
Then, if | v T θ | ≥ 0 . 5 , we add v to the set of arms.
Otherwise, we reject the vector and keep repeating this procedure until we reach a total of 50 arms.
We thus obtain random linear instances where the first 10 arms are hard to learn since they have small gap (i.e., the absolute mean, which is between 0 . 1 and 0 . 2 ), and all remaining 40 arms have moderate to large gap (at least 0 . 5 ) and are thus easy to eliminate.
Unstructured instances (experiments of Appendix G.3.2)
We used K = 40 arms.
For BAI and
Top-m, the mean reward of the first 5 arms is µ 1 = 1 , µ 2 = 0 .
9 , µ 3 = 0 .
8 , µ 4 = 0 .
7 , and µ 5 = 0 .
For all remaining arms the mean reward is uniformly drawn in [0 , 0 . 5] .
For OSI, the mean reward of the first 4 arms is µ 1 = 0 .
1 , µ 2 = − 0 .
2 , µ 3 = 0 .
3 , and µ 4 = − 0 .
For all remaining arms the mean reward is uniformly drawn in [ − 1 , − 0 .
5] ∪ [0 . 5 , 1] .
[Table]
G.3 Additional Results G.3.1 Full versus selective elimination
We report in Table
the full results of the experiment comparing elimination rules (full vs selective) from which we extracted Figure 2 (middle) .
We recall that the linear instances for this experiment were generated as explained in the first paragraph of Appendix G.2.
We did not compare full and selective elimination rules on OSI since, as explained in Appendix B, they are actually equivalent in such a setting.
While we saw in Figure 2 (middle) that the full elimination rule allows eliminating some arms earlier than the selective one, we notice from Table 3 that the former rule actually yields no advantage in terms of sample complexity.
Moreover, its computational overhead makes it much slower than the selective elimination rule.
Therefore, in practice we suggest using the selective elimination rule, which always yields reduced computation times and often improved sample complexity.
G.3.2 Unstructured instances
We report the results on unstructured bandit instances (generated according to the procedure of
Appendix G.2) in Table 4.
The algorithm k-Learner is the unstructured variant of LinGame proposed by [15].
We note that the results are coherent with those for linear instances presented in the main paper.
In particular, we observe a reduction in computation times when combining adaptive algorithms with selective elimation.
The reduction is however less evident than in the linear case.
This is expected since, in general, eliminations are easier in structured problems than in unstructured ones.
We also note that combining sampling rules with selective elimination slightly improves the sample complexity of all algorithms.
[Table]
H Examples H.1 Running example
Consider BAI in a Gaussian linear bandit instance with unit variance, d = and arbitrary number of arms K ≥ 3 (see Figure 3 for an example with K = 5 ).
The arm features are ϕ 1 = (1 , 0) T , ϕ
= (0 , 1) T and, for all i = 3 , . .
, K , ϕ i
= ( a i , b i ) T with a i , b i arbitrary values in ( − 1 , 0)
such that ∥ ϕ i ∥ 2 = 1 .
The true parameter is θ =
(1 , 1 − ε ) T , for ε ∈ (0 , 1 / 2) a possibly very small value.
Arm 1 is optimal with mean µ 1 ( θ ) = 1 , while arm 2 is sub-optimal with mean µ 2 ( θ ) = 1 − ε .
For all other arms i = 3 , . . .
, K , µ i ( θ ) ≤ 0 .
Let
ω ∈ ∆ K be any allocation.
Recall that in BAI each piece index is simply an arm, and P ( i ⋆ ( θ )) =
P (1) = { 2 , . . .
, K } .
Let k ∈ P (1) be any sub-optimal arm.
The distance to the k -th alternative piece H k ( ω, θ ) can be computed in closed form as
[Equation]
It can be determined that the optimal allocation, solution to arg max ω min k H k ( ω, θ ) , is ω ⋆ = (1 / 2 , 1 / 2 , 0 , . . . , 0) ⊤ .
We will prove this as a consequence of Lemma H.1 below.
The intuition why this example is interesting is as follows.
Any correct strategy is required to discriminate between arm 1 and 2 (i.e., to figure out that arm 1 is optimal), which requires roughly
O (1 /ε 2 ) samples from both.
An optimal strategy plays these two arms nearly with the same proportions.
Since ϕ 1 and ϕ 2 form the canonical basis of R 2 , the samples collected by this strategy are informative for estimating the mean reward of every arm, even those than are not played.
Then, since arms 3 , . . .
, K have at least a sub-optimality gap of 1 , an elimination-based strategy discards them with a number of samples not scaling with 1 /ε 2 .
This means that a non-elimination strategy runs for O (1 /ε 2 ) steps over the original problem with K arms, while an elimination-based one quickly reduces the problem to one with only 2 arms.
The main impact is computational: since most algorithms need to compute some statistics for each active arm at each round (e.g., closest
[Figure]
alternatives, confidence intervals, etc.)
and that requires at least one loop over the set of active arms, the computational complexity of a non-elimination algorithm is at least O ( K/ε 2 ) , while the one of an elimination-based variant is roughly O
( K + 1 /ε 2 ) , a potentially very large improvement.
Remark.
The fact that certain arms are discarded very early is not only due to their large suboptimality gap but also to the linear structure of the problem (i.e., to the fact that pulling certain arms provides information about others).
In fact, if we consider an equivalent bandit problem with the same mean rewards but with K -dimensional features such that ϕ k = e k (the k -th vector of the canonical basis of R K ) for all k , then pulling an arm provides no information about the others.
In this unstructured case, it is known that an optimal allocation ω ⋆ makes all the half-spaces at the same distance.
That is, H k ( ω, θ ) is the same for all k and thus no arm is eliminated early.
The following result formalizes the intuition that arms 3 , . .
, K can be eliminated much earlier than arm 2 .
It shows that, for any allocation ω and k > 2 , the distance H k ( ω, θ ) to the k -th alternative piece is at least a factor 1 /ε 2 larger than the distance H 2 ( ω, θ ) to the second alternative piece.
Lemma H.1.
For any ω and k = 3 , . . .
, K , H k ( ω, θ ) ≥ (1 − ε )
ε 2 H 2 ( ω, θ ) .
Proof.
For k > 2 , Λ k ( i ⋆ ) ⊆ { η | η 1 ≤ 0 } ∪ { η | η 2 ≤ 0 } .
Hence the distance from θ to Λ k
( i ⋆ ) in
V ω -norm is greater than the minimal distance to each of those two half spaces.
The closest points to θ in those two half spaces are (0 , 1 − ε ) ⊤ and (1 , 0) ⊤ , respectively.
We get
[Equation]
Since we have 2 × 2 matrices, let us get concrete and write V ω
= (cid:18) a b b d (cid:19) .
By our hypotheses on all ϕ k , b ≥ 0 . .
We get that d = 1 − a by computing the trace of V ω : tr( V ω )
= tr( (cid:80) k ω k ϕ k ϕ ⊤ k ) = (cid:80)
k ω k tr( ϕ k ϕ ⊤ k ) =
(cid:80)
k ω
k ϕ ⊤ k ϕ k
= 1 .
Then V − 1 ω =
[Equation]
1 a
[Equation]
−
[Equation]
) −
[Equation]
2 (1 + 2 b ) .
Thus,
[Equation]
and
[Equation]
We finally obtain a comparison between H k ( ω, θ ) for k > 2 and H 2 ( ω, θ ) :
[Equation]
Corollary H.2.
The optimal allocation for this problem is ω
⋆ = (1 / 2 , 1 / 2 , 0 , . . . , 0) ⊤ .
Proof.
By Lemma H.1, since ε < 1 / 2 the minimum over H k is attained by H 2 no matter what ω is, hence the optimal allocation belongs to arg max ω
H 2 ( ω, θ ) .
With the notation of that lemma,
H 2 ( ω, θ ) =
ε 2 ( a (1 − a ) − b 2 ) 2(1+2 b ) where a ∈ [0 , 1] , b ≥ 0 are coefficients of V ω .
We get that (if that’s attainable), the optimal value is reached for a = 1 / 2 , b = 0 .
By construction of our arms ϕ k , b = 0 implies that ω is supported on the two first coordinates.
a = 1 / 2 can then be attained by (1 / 2 , 1 /
⊤
. H.2 An oracle strategy with elimination at stopping provably reduces the computational complexity w.r.t. LLR stopping
Consider an “oracle” strategy which tracks the optimal proportions ω
⋆ from the lower bound, i.e., the arm played at time t is k t = arg min k
( N kt − 1 − tω ⋆k ) .
Proposition H.3.
For any K ≥ 3 and ε ∈ (0 , 1 / 2) , the exists a Gaussian linear BAI instance with unit variance and d = 2 such that, for any δ ∈ (0 , 1) , the oracle strategy combined with LLR stopping satisfies
[Equation]
On the same instance, suppose we run the oracle strategy with elimination at stopping using a threshold β t,δ = log(1 /δ )
+ O (log( t )) .
Then, for all but 2 arms, the expected elimination time of the corresponding piece is, for full elimination,
[Equation]
while for selective elimination,
[Equation]
Here (cid:101)
O hides constant and logarithmic terms.
Proof.
Consider the problem defined in the example of Appendix H.1.
It is easy to see that, on such instance, the oracle sampling rule simply alternates between pulling arm 1 and arm 2 .
The first result is immediate from the lower bound E [ τ ] ≥ log (cid:0) 12 .
4 δ (cid:1) /H
⋆ ( θ ) .
We only need to compute
H ⋆ ( θ ) =
max ω min k H k ( ω, θ ) .
By Lemma H.1, since ε < 1 / 2 the minimum is equal to H 2 ( ω, θ ) .
Since ω ⋆ = (1 / 2 , 1 / 2 , 0 , . . . , 0) T , using the closed-form expression of the infimum over each alternative piece as stated above,
[Equation]
This proves the first result.
Let us now prove the second one.
We use the upper bound on the elimination time of pieces from Theorem 2.6.
Note that, for each time t even, we have that N t /t = ω
⋆ , which implies that R ( θ, t ) = 0 .
Therefore, for each k = 3 , . .
, K , E [ τ k ] ≤ ¯ t k + 3 , where ¯ t k is the first integer such that
[Equation]
with G ( θ, t ) = 0 for full elimination and G ( θ, t ) = 4 β t, 1 /t 2 H ⋆ ( θ ) for selective elimination.
For all k = 3 , . . .
, K , using Lemma H.1,
[Equation]
Now, for full elimination, since β t,δ = log(1 /δ )
+ O (log( t ))
and H k ( ω ⋆ , θ ) ≥ 1 / 32 as proved above, ¯ t k is below the first time t such that
[Equation]
which yields ¯ t k ≤ (cid:101)
O (log(1 /δ )) .
The same reasoning can be done for selective elimination, which yields the stated bound.
An immediate consequence of Proposition H.3 is that the total computational complexity of the oracle strategy can be significantly reduced with elimination, especially in the regime where δ and ε are small.
Proposition H.4.
On the same instance constructed in Proposition H.3, the expected per-round computation time of the oracle strategy with LLR stopping is Ω( K ) , while it is at most O ( K 2 ε 2 ) for full elimination and O ( Kε 2 + K/ log(1 /δ )) for selective elimination.
Proof.
The per-round complexity of the oracle strategy with LLR stopping is Ω( K ) since checking the stopping rule requires computing the infimum LLR for exactly K − 1 alternative pieces at each step.
Full elimination requires two nested loops over the set of active arms, which take at most
O ( K 2 ) complexity (when no arm has been eliminated).
By Proposition H.3, this set is of size at most K only until time (cid:101)
O (log(1 /δ )) , while it is of cardinality at most 2 after that.
Since the total sample complexity is (cid:101)
O (log(1 /δ )
/ε 2 )
(the same as LLR stopping), the total computation time is
O ( K 2 log(1 /δ )
+ log(1 /δ )
/ε 2 )
and the average one is thus the stated quantity.
Similarly, selective elimination requires a single loop over all active arms at each step, which takes at most O ( K ) complexity.
Again, by Proposition H.3, this set is of size at most K only until time (cid:101)
O (log(1 /δ )
+ 1 /ε 2 ) , while it is of cardinality at most 2 after that.
Therefore, the total computation complexity is
O ( K log(1 /δ )
+ K/ε 2 + log(1 /δ )
/ε 2 ) .
Dividing by the total number of rounds log(1 /δ )
/ε 2 gives the stated bound.
H.3 Low information regret with elimination at stopping provably discards many arms early
Proposition H.5.
For any K ≥ 3 and ε ∈ (0 , 1 / 2) , there exists a Gaussian linear BAI instance with unit variance and d = 2 such that, for any δ ∈ (0 , 1) , any low information regret sampling rule combined with LLR stopping satisfies
[Equation]
On the same instance, suppose we run the same strategy with elimination at stopping using a threshold β t,δ = log(1 /δ )
+ O (log( t )) .
Let T ε :=
inf t { t : R ( θ, t ) /t ≤ ε 2 / 16 } (note that this quantity is constant in δ ).
Then, for all but 2 arms, the expected elimination time of the corresponding piece is, for full elimination,
[Equation]
while for selective elimination,
[Equation]
Here (cid:101)
O hides constant and logarithmic terms.
Remark .
On the instance constructed in Proposition H.5, we actually have H ⋆ ( θ ) =
ε 2 / 8 while, for any γ ∈ (0 , ε 2 / 16] and k > 2 ,
min ω ∈ Ω γ ( θ ) H k ( ω, θ ) ≥ 1 / 64 .
This implies that, from Theorem 2.6, all but two arms are eliminated way before stopping by any low information regret sampling rule.
Proof.
Consider the problem defined in the example of Appendix H.1.
The first result has already been proved in Proposition H.3.
Let us prove the second one.
We use the upper bound on the elimination time of pieces from Theorem 2.6.
For arm k > 2 , the denominator scales as
[Equation]
Suppose that t ≥ T ε :=
inf t { t : R ( θ, t ) /t ≤ ε 2 / 16 } .
Then, by definition of the set Ω , any ω ∈ Ω R ( θ,t ) /t
( θ ) satisfies
[Equation]
Combining this result with Lemma H.1,
[Equation]
Then, from Theorem 2.6 combined with the condition t ≥ T ε , E [ τ k ] ≤ ¯ t k + 2 + T ε , where ¯ t k is the first integer such that
[Equation]
with G ( θ, t ) = 0 for full elimination and G ( θ, t ) = 4 β t, 1 /t 2 H ⋆ ( θ ) for selective elimination.
We can now conclude as in the proof of Proposition H.3.
I Additional details
for
̸ =
⋆ (ˆ θ t ) do ▷ stopping
L i,t = min λ ∈ Λ i ( i ⋆ (ˆ θ t ))
∥
ˆ θ t − λ ∥ 2 V Nt end for if min i ̸
= i ⋆
(ˆ θ t )
L i,t > β t,δ then STOP
Get w t from a learner L for i ̸
= i ⋆
(ˆ θ t )
do ▷ sampling λ i,t =
arg min
λ ∈ Λ i ( i t )
∥
ˆ θ t − λ ∥ 2 V wt end for λ t = arg min i ̸
= i ⋆
(ˆ θ t )
∥
ˆ θ t − λ i,t ∥ 2 V wt Update L with losses based on λ t
Pull arm k t =
arg min k N kt − (cid:80) ts =1 w s end while while not stopped do
Set P stp t ( i ⋆ (ˆ θ t )) =
P stp t − 1 ( i ⋆ (ˆ θ t )) for i ∈ P stp t − 1 ( i ⋆ (ˆ θ t )) do ▷ stopping
L i,t = min λ ∈ Λ i ( i ⋆ (ˆ θ t ))
∥
ˆ θ t − λ
∥ 2 V Nt if L i,t >β t,δ delete i from P stp t
( i ⋆ (ˆ θ t )) end for if P stp t ( i ⋆ (ˆ θ t ))
= ∅ then STOP
Get w t from a learner L for i
∈ P smp t ( i ⋆ (ˆ θ t ))
do ▷ sampling λ i,t =
arg min
λ ∈ Λ i ( i t )
∥
ˆ θ t − λ ∥ 2 V wt end for λ t = arg min i ∈P smp t
( i ⋆ (ˆ θ t ))
∥
ˆ θ t − λ i,t ∥ 2 V wt
Update L with losses based on λ t Pull arm k t = arg min k N kt − (cid:80) ts =1 w s
Update P smp t +
( i ⋆ (ˆ θ t ))
(Algorithm 3) end