Dueling Bandits with Adversarial Sleeping

Abstract:
We introduce the problem of sleeping dueling bandits with stochastic preferences and adversarial availabilities (DB-SPAA). In almost all dueling bandit applications, the decision space often changes over time; eg, retail store management, online shopping, restaurant recommendation, search engine optimization, etc. Surprisingly, this ‘sleeping aspect’ of dueling bandits has never been studied in the literature. Like dueling bandits, the goal is to compete with the best arm by sequentially querying the preference feedback of item pairs. The non-triviality however results due to the non-stationary item spaces that allow any arbitrary subsets items to go unavailable every round. The goal is to find an optimal ‘no-regret’ policy that can identify the best available item at each round, as opposed to the standard ‘fixed best-arm regret objective’ of dueling bandits. We first derive an instance-specific lower bound for DB-SPAA Ω( ∑K−1 i=1 ∑K j=i+1 log T ∆(i,j) ), where K is the number of items and ∆(i, j) is the gap between items i and j. This indicates that the sleeping problem with preference feedback is inherently more difficult than that for classical multi-armed bandits (MAB). We then propose two algorithms, with near optimal regret guarantees. Our results are corroborated empirically.

text: ∑K−1 i=1 ∑K j=i+1 log T ∆(i,j) ), where K is the number of
items and ∆(i, j) is the gap between items i and j. This indicates that the sleeping problem with preference feedback is inherently more difficult than that for classical multi-armed bandits (MAB). We then propose two algorithms, with near optimal regret guarantees. Our results are corroborated empirically.

heading: 1 Introduction
text: The problem of Dueling-Bandits has gained much attention in the machine learning community [34, 38, 36], which is an online learning framework that generalizes the standard multiarmed bandit (MAB) [6] setting for identifying a set of ‘good’ arms from a fixed decision-space (set of arms/items) by querying preference feedback of actively chosen item-pairs. More formally, in dueling bandits, the learning proceeds in rounds: At each round, the learner selects a pair of arms and observes stochastic preference feedback of the winner of the comparison (duel) between the selected arms; the objective of the learner is to minimize the regret with respect to a (or set of) ‘best’ arm(s) in hindsight. Towards this several algorithms have been proposed [2, 37, 21, 14]. Due to the inherent exploration-vs-exploitation tradeoff of the learning framework and several advantages of preference feedback [9, 35], many real-world applications can be modeled as dueling bandits, including movie recommendations, retail management, search engine optimization, job scheduling, etc.
However, in reality, the decision spaces might often change over time due to the non-availability of some items, which are considered to be ‘sleeping’. This ‘sleeping-aspect’ of online decision making problems has been widely studied in the standard multiarmed bandit (MAB) literature [17, 24, 15, 19, 18, 11]. There the goal is to learn a ‘no-regret’ policy that maps to the ‘best awake item’ of any available (non-sleeping) subset of items, and the learner’s performance is measured with respect to the optimal policy in hindsight. This setting is famously known as Sleeping Bandits in MAB [17, 24, 15, 11]. More discussions are given in Related Works.
Surprisingly, however, the ‘sleeping problem’ is completely unaddressed in the preference bandits literature, even for the special case of pairwise preference feedback, which is famously studied ∗Microsoft Research, New York, US; aasa@microsoft.com. †Univ. Grenoble Alpes, Inria, CNRS, Grenoble INP, LJK, 38000 Grenoble, France.
pierre.gaillard@inria.fr
35th Conference on Neural Information Processing Systems (NeurIPS 2021).
as Dueling Bandits [37, 34], even though the setup of changing decision spaces are quite relevant in almost every practical applications: Be that in retail stores where some items might go out of production over time, for search engine optimization some websites could be down on certain days, in recommender systems some restaurants might be closed or movies could be outdated, in clinical trials certain drugs could be out of stock, and many more. This work is the first to consider the problem of Sleeping Dueling Bandits, where we formulated the stochastic K-armed dueling bandit problem with adversarial item availabilities. Here at each round t ∈ {1, 2, . . . , T} the item preferences are considered to be generated from a fixed underlying (and of course unknown) preference matrix P ∈ [0, 1]K×K , however, the set of available actions St ⊆ {1, 2, . . . ,K} is assumed to be adversarially chosen by the environment. We call the problem as Sleeping-Dueling Bandit with Stochastic Preferences and Adversarial Availabilities or in brief DB-SPAA(P,ST ), where ST = {S1, S2, . . . ST } denotes the sequence of available subsets over T rounds. We also assume the preference P follows a ‘total-ordering assumption to ensure the existence of a best-item per available subset St. We describe the setting in Fig. 1 with a formal description in Sec. 2.
Our specific contributions are as follows:
1. We first analyze the fundamental performance limit for the DB-SPAA(P,ST ) problem in Sec. 3: Thm. 1 gives an instance-specific regret lower bound of
Ω (∑K−1
i=1 ∑K j=i+1 log T ∆(i,j) ) ,
with ∆(i, j) being the ‘preference gap’ of item i-vs-j (see Eqn. (2)). Our lower bound, which can be of order Ω(K2 log T/∆), ∆ := mini,j ∆(i, j) being the worst case gap, indicates that the problem of sleeping dueling bandits is inherently more difficult that standard sleeping bandits (MAB), unlike the ‘non-sleeping’ case where both dueling bandits (with ‘total-ordering’ assumption on P) and MAB are known to have the same fundamental performance limit of Ω(K log T/∆) (Rem. 1).
2. We next design a ‘fixed confidence regret’ algorithm SlDB-UCB (Alg. 1), inspired from the pairwise upper confidence bound (UCB) based algorithm [37]. However due to the fixed confidence and ‘adversarial-sleeping’ nature of the problem, we need to differently maintain pairwise confidence bounds per item (based on the availability sequence {St}), which makes the resulting algorithm and its subsequent analysis significantly different than standard UCB based dueling bandit algorithms: Precisely given any δ > 0, SlDB-UCB achieves a regret of O ( K3 log(1/δ)
∆2
) with probability at least
1− δ over any problem instance of DB-SPAA(P,ST ) (Sec. 4).
3. In Sec. 5, we design another computationally efficient algorithm, SlDB-ED (Alg. 2), for ‘expected regret’ guarantee. Unlike the previous algorithm (SlDB-UCB), SlDB-ED uses empirical divergence (ED) based measures to filter out the ‘good’ set of arms, inspired from the idea of RMED algorithm of [21] for standard dueling bandits; however, due to sleeping nature of the items, it requires a different maintenance of ‘good’ arms and the regret analysis of the algorithm requires derivation of new results (as described in Sec. 5). The algorithm is shown to perform near optimally with an expected non-asymptotic regret upper-bound of (Thm. 6). Note that for any problem instance with constant suboptimality gaps ∆(i, j) = ∆ for all i < j, regret bound of SlDB-ED is tight and matches the lower-bound ensuring the near optimality of SlDB-ED in the worst case. Furthermore, a novelty of our finite time regret analysis lies in showing a cleaner tradeoff between regret vs. availability sequence ST which automatically adapts to the inherent ‘hardness’ of the sequence of available
subsets ST , compared to existing sleeping bandits work for adversarial availabilities in the MAB setting [19] which only gives a worst-case regret bound over all possible availability sequences (Rem. 3).
4. Finally we corroborate our theoretical results with extensive empirical evaluations. (Sec. 6).
Related Works. The problem of regret minimization for stochastic multiarmed bandits (MAB) is extremely well studied in the online learning literature [6, 1, 22, 5, 16], where the learner gets to see a noisy draw of absolute reward feedback of an arm upon playing a single arm per round.
A well motivated generalization of MAB framework is Sleeping Bandits [17, 24, 18, 15], much studied in the online learning community, where at any round the set of available actions could vary stochastically based on some unknown distributions over the decision space of K items [24, 11] or adversarially [15, 19, 18]. Besides the reward model, the set of available actions could also vary stochastically or adversarially [17, 24]. The problem is NP-hard when both rewards and availabilities are adversarial [19, 18, 15]. In case of stochastic reward and adversarial availabilities [19] proposed an UCB based no-regret algorithm, which was also shown to be provably optimal. The case of adversarial reward and stochastic availabilities has also been studied where the achievable regret lower bound is known be Ω( √ KT ) by the inefficient EXP4 algorithm [19, 15].
On the other hand over the last decade, the relative feedback variants of stochastic MAB problem has seen a widespread resurgence in the form of the Dueling Bandit problem, where, instead of getting noisy feedback of the reward of the chosen arm, the learner only gets to see a noisy feedback on the pairwise preference of two arms selected by the learner. The objective of the learner is to minimize the regret with respect to ‘best arm in the stochastic model. Several algorithms have been proposed to address this dueling bandits problem, for different notions of ‘best arms’ or preference models [10, 31, 38, 37, 36, 21, 33, 13], or even extending the pairwise preference to subsetwise preferences [29, 8, 26, 27, 25]. However, surprisingly, unlike the ‘sleeping bandits generalization’ of MAB, no parallel has been drawn for dueling bandits, which remains our main focus.

heading: 2 Problem Formulation
text: Notations. Decision space (or item/arm set) [K] := {1, 2, . . . ,K}. The available set of items at round t is denoted by St ⊆ [K]. For any matrix M ∈ RK×K , we definemij := M(i, j), ∀i, j ∈ [K]. We write S\i = S \ {i}, for any S ⊆ [K] and i ∈ S. 1(·) denotes the indicator random variable which takes value 1 if the predicate is true and 0 otherwise and. a rough inequality which holds up to universal constants. For any two items x, y ∈ [K], we use the symbol x y to denote x is preferred over y. ΣK denotes the set of all permutations of the items in set [K]. The KL-divergence of two Bernoullis with biases p and q respectively is written kl(p, q) := p log(p/q) + (1− p) log((1−p)/(1−q)). We assume 00 := 0.5 (in Alg. 1 and 2).
Setup. We consider the problem of stochastic K-armed dueling bandits with adversarial availabilities: At every iteration t = 1, . . . , T , a set of available items (actions) St ⊆ [K] is revealed, and the learner is asked to choose two items xt, yt ∈ St. Then, the learner receives a preference feedback ot = 1(xt yt) ∼ Ber(P(xt, yt)), where P ∈ [0, 1]K×K is an underlying pairwise preference matrix, unknown to the learner. The setting is described in Figure 1. We assume that P respects a
‘total ordering’, say σ∗ ∈ ΣK . Without loss of generality, we set σ∗ = (1, 2, . . . ,K) thoughout the paper. This implies P(i, j) ≥ 0.5 for i ≤ j. One possible pairwise probability model which respects ‘total ordering’ is Plackett-Luce [7], where it is assumed that the K items are associated to positive score parameters θ1, . . . , θK , and P(i, j) = θi/(θi + θj) for all i, j ∈ [K]. In fact any well random utility (RUM) based preference model would have the above property, like [7, 28]. Note also that our assumption corresponds to assuming the existence of a Condorcet winner for every subset St ⊆ [K].
Objective. The objective of the learner is to minimize his regret over T rounds with respect to the best policy in the policy class Π = {π : 2K 7→ [K] | ∀t ∈ [T ], π(St) ∈ St}, i.e. any π ∈ Π is such that for any t ∈ [T ], π(St) ∈ St. More formally we define the regret as follows:
RT = max π∈Π T∑ t=1 P(π(St), xt) + P(π(St), yt)− 1 2 . (1)
We analyze both fixed-confidence and expected regret guarantees in this paper respectively in Sec. 4 (see Thm. 3) and Sec. 5 (see Thm. 6). It is easy to note that under our preference modelling assumptions, the best policy, say π∗, turns out to be π∗(S) = min{S} for any S ⊆ [K]. We henceforth denote by i∗t = π
∗(St). We define the above problem to be Sleeping-Dueling Bandit with Stochastic Preferences and Adversarial Availabilities over the stochastic preference matrix P ∈ [0, 1]K×K and the sequence of available subsets ST = {S1, . . . , ST }, or in short DB-SPAA(P,ST ). For ease of notation we respectively define the gaps and the non-zeros gaps as ∆(i, j) := P(i, j)−1/2, and
∆(i, j)+ := { ∆(i, j) if ∆(i, j) 6= 0 +∞ if ∆(i, j) = 0 (2)
The regret thus can be rewritten as RT := ∑T t=1 rt, where rt := (∆(i ∗ t , xt) + ∆(i ∗ t , yt))/2 denotes
the instantaneous regret. We also denote by nij(t) := ∑t τ=1 1 ( {xt, yt} = {i, j} ) the number of times the pair (i, j) is played until time t and by wij(t) the number of times i beats j in t rounds.

heading: 3 Lower Bound
text: We first derive a worst case regret lower bound over all possible sequences of ST . The proof idea essentially lies in constructing hard enough availability sequences ST , where no learner can escape learning the preferences of every distinct pair of items (i, j). This leads to a potential lower bound of Ω ( K2 log(T )/∆ ) . For this section we denote P by PK to make the dependency on K more precise.
Theorem 1 (Lower Bound for DB-SPAA(PK ,ST )). For any No-regret learning algorithm A, there exists a problem instance DB-SPAA(PK ,ST ) with T ≥ K4, such that its expected regret is lowerbounded as:
E[RT (A)] ≥ Ω (K−1∑
i=1 K∑ j=i+1 log T ∆(i, j)+ ) .
The No-regret learning algorithm refers to the class of ‘consistent algorithms’ which do not pull any suboptimal pair more than O(Tα), α ∈ [0, 1] (see Def. 7, Appendix 8)). Proof (sketch) The main argument lies behind the fact that in the worst case the adversary can force the algorithm to learn the preference of every distinct pair (i, j) as for the ‘worst-case’ sequences ST , a knowledge of the already ‘learnt’ pairwise preferences would not disclose any information on the remaining pairs; e.g. assuming σ∗ = (1, 2, . . . ,K), revealing the available subsets in the following sequence (1, 2), (1, 3), . . . (1,K), (2, 3), (2, 4), . . . (K − 1,K) would force the learner to explore (learn the preferences) all ( K 2 ) distinct pairs. The remaining proof establishes this formally, towards which we first show a Ω(ln(T )/∆(1, 2)) regret lower bound for a DB-SPAA instance with just two items (i.e. K = 2) as shown in Lem. 2. The lower bound for any general K can now be derived applying the above bound on independent ( K 2 ) subintervals, with the availability sequence (1, 2), (1, 3), . . . (1,K), (2, 3), (2, 4), . . . (K − 1,K). The full proof is given in Appendix 8. Lemma 2 (Lower Bound of DB-SPAA(PK ,ST ) for 2 items). For any No-regret learning algorithm A, there exists a problem instance DB-SPAA(P2,ST ) such that the expected regret incurred by A on that can be lower bounded as: E[RT (A)] ≥ ∆−1 log(T ), ∆ being the ‘preference-gap’ between the two items (i.e. ∆ = P12 − 1/2, assuming P12 > 1/2 or equivalently ∆ > 0). Remark 1 (Implication of the lower bound). The above result indicates that in the preference based learning setup, the fundamental problem complexity lies in distinguishing every pair of items 1 ≤ i < j ≤ K. If the learner fails to learn the preference of any pair (i, j), the adversary can make the learner suffer O(T ) regret by setting St = {i, j} henceforth at all round. It is worth noting that in the ‘no sleeping’ case both dueling bandits and MAB are known to have the same fundamental performance limit of Ω(K log(T )/∆) (assuming P respects a condorcet winner [6, 21]). Thus Thm. 1 shows that the ‘sleeping-aspect’ of dueling bandits makes the problem K-times harder than ‘sleepingMAB’ for which the regret lower bound is known to be only Ω (∑K i=1 log(T )/∆(i, i+ 1) ) [19].
Algorithm 1 SlDB-UCB 1: input: Arm set: [K], parameters α > 0.5, Confidence parameter δ ∈ [0, 1) 2: init: wij(1)← 0,∀i, j ∈ [K]. 3: define: nij(t) := wij(t) + wji(t), ∀t ∈ [T ] 4: for t = 1, 2, . . . , T do 5: Receive St ⊆ [K]
6: p̂ij(t) = wij(t)
nij(t) , cij(t)←
√ α log aij(t)
nij(t) , ∀i, j ∈ St, (assume x0 := 0.5, ∀x ∈ R)
7: uij(t)← p̂ij(t) + cij(t), uii(t)← 1/2, ∀i, j ∈ St . UCB of empirical preferences 8: for k ∈ St do 9: Ck(t) := {j ∈ St | ukj(t) > 1/2} . Potential losers to k 10: end for 11: Ct = {i ∈ St | |Ci(t)| = maxj∈St |Cj(t)|} . Potential best items 12: Select a random xt from Ct. Choose yt ← arg maxi∈Ct uixt(t) 13: Play (xt, yt). Receive preference ot 14: Update: ∀i, j ∈ [K], wxtyt(t + 1) ← wxtyt(t) + ot, wytxt(t + 1) ← wytxt(t) + (1 − ot), aij(t+ 1)← max{nij(t+ 1), C(K, δ)}, ∀i, j ∈ [K] 15: end for
4 SlDB-UCB: A Fixed-Confidence Algorithm
In this section, we design an efficient algorithm for the DB-SPAA(K,T ) problem with instancedependent regret guarantee.
Main ideas. Our algorithm, described in Alg. 1, depends on an hyper-parameter α > 0.5 and a confidence parameter δ > 0. It maintains, for each item k ∈ [K], its own record of empirical pairwise estimates of the duels, (i, j) ∈ [K]× [K] and their respective upper confidence bounds defined as:
p̂ij(t) := wij(t) nij(t)
and uij(t) := p̂ij(t) + cij(t), with cij(t) := √
α log aij(t) nij(t) ,
where wij(t) denotes the total number of times item i beats j up to round t, nij(t) := wij(t)+wji(t), and for all i, j ∈ [K] and t ∈ [T ]
aij(t) := max{C(K, δ), nij(t)} and C(K, δ) := ( (4α−1)K2 (2α−1)δ ) 1 2α−1 .
A key observation is that our careful choice of the confidence bounds cij(t) ensures that with high probability pij(t) ∈ [p̂ij(t) − cij(t), p̂ij + cij(t)] for any duel i, j ∈ [K] and any t ∈ [T ] (Lem. 4). Now at any round t ≥ 1, the algorithm first computes a set of potential winners of St as Ct = {k ∈ St | |Ck(t)| = maxj∈St |Cj(t)|}, where Ck(t) := {j ∈ St | ukj(t) > 12} denotes the set of items that item k dominates (optimistically). At each round, we play a random item from the set potential winners Ct as the left arm xt. Finally the right-arm yt is chosen to be the most competitive opponent of xt as yt ← arg maxi∈Ct uji(t) from the potential winners. Our arm selection strategy ensures that eventually for all t, algorithm plays the optimal pair (i∗t , i ∗ t ) frequently enough as desired.
Theorem 3 (Fixed-confidence regret analysis: SlDB-UCB). Given any δ > 0 and α > 1/2, with probability at least 1− δ, the regret incurred by SlDB-UCB (Alg. 1) is upper-bounded as:
RT ≤ 2 K−1∑ i=1 K∑ j=i+1 Mij log ( 2C(K, δ)Mij ) where
C(K, δ) :=
( (4α− 1)K2
(2α− 1)δ
) 1 2α−1 and Mij = i∑
k=1
4α min { ∆(k, i)+,∆(k, j)+ }2 .
The complete proof with a precise dependencies on the model parameters is deferred to Appendix 9. Remark 2. The dependency on ∆ = mini,j ∆+(i, j) does not match the lower-bound of Thm. 1, which is of order O(log(T )/∆). Instead, Thm. 3 proves O(log(1/δ)/∆2). Yet, the bounds are
not directly comparable because the lower-bound is on the expected regret while the upper-bound considers fixed-confidence δ and is hence independent of T . All existing dueling bandit algorithms, that minimize the expected regret, suffer an additional constant term of order O(1/∆2) –see for instance [37, 21]. Achieving an order O(1/∆) dependendence is an interesting question for future work.
Proof sketch of Thm. 3. The key steps lie in proving the following four lemmas. The first lemma follows along the line of Lem. 1 of RUCB algorithm [37]and shows that all the pairwise estimates are contained within their respective confidence intervals with high probability.
Lemma 4. Let α > 0.5 and δ > 0. Then, for any i, j ∈ [K], with probability at least 1− δ/K2,
p̂ij(t)− cij(t) ≤ pij ≤ uij(t) := p̂ij(t) + cij(t), ∀t ∈ [T ] .
The lemma below shows that once the algorithm can not play any suboptimal pair ‘too many times’.
Lemma 5. Let α > 0.5. Under the notations and the high-probability event of Lem. 4, for all i, j, k ∈ [K] such that {i, j} 6= {k, k}, and for any τ ≥ 1
τ∑ t=1 1(i∗t = k)1 ( {xt, yt} = {i, j} ) ≤ 4α log ai,j(τ) min { ∆(k, i)+,∆(k, j)+ }2 ,
where recall aij(τ) = max ( C(K, δ), nij(τ) ) .
With probability of at least 1 − δ, the event of Lem. 4 holds and thus so do the ones of Lem. 5. The regret of Alg. 1 then follows from applying the above lemmas with the following careful decomposition of the regret:
RT ≤ K−1∑ i=1 K∑ j=i+1 T∑ t=1 i∑ k=1 1(i∗t = k)1 ( {xt, yt} = {i, j} ) = K−1∑ i=1 K∑ j=i+1 nij(T )
and the proof is concluded by using Lemma 5 to upper-bound nij(T ). The complete proof given in Appendix 9.
5 SlDB-ED: An Expected Regret Algorithm
In this section, we propose another computationally efficient algorithm, SlDB-ED (Alg. 2), which achieves near-optimal expected-regret for DB-SPAA problem, and also performs competitively against SlDB-UCB empirically (see Sec. 6). Furthermore, a novelty of our finite time regret analysis of SlDB-ED lies in showing a cleaner trade-off between regret vs availability sequence ST which automatically adapts to the inherent ‘hardness’ of the sequence of available subsets ST , unlike the previous attempts made in standard sleeping bandits for adversarial availabilities [19] (Rem. 3).
Main ideas. We again use the notations wij(t), nij(t) as used for SlDB-UCB (Alg. 1), with the same initializations. Same as SlDB-UCB, this algorithm also maintains the empirical pairwise preferences p̂ij(t) for each item pair i, j ∈ [K]. However, unlike the earlier case here we need to ensure an initial t0 rounds of exploration (t0 = 1 in the theorem) for every distinct pairs (i, j), and instead of maintaining pairwise UCBs, in this case the set of ‘good-items’ is defined in terms of empirical divergences for all i ∈ St
Ii(t) := ∑
j∈B̂i(t)
nij(t) kl ( p̂ij(t), 1/2 ) , B̂i(t) := { j ∈ [K] \ {i} | p̂ij(t) ≤ 1/2 } ∩ St
denotes the empirical winners of item i in set St. Now intuitively since exp(−Ii(t)) can be interpreted as the likelihood of i being the best-item of St, we denote by î∗t ← arg mini∈St Ii(t) the empiricalbest item of round t and define the set of ‘near-best’ items Ct := { i ∈ St | Ii(t)− Îi∗t (t) ≤ α log t } , whose likelihood is close enough to that of î∗t . Finally the algorithm selects an arm pair (xt, yt) such that xt is a potential candidate of good arm (which ensures the required exploration) and yt being the strongest challenger of xt w.r.t the empirical preferences. The algorithm is given in Alg. 2.
Algorithm 2 SlDB-ED 1: input: Arm set: [K], exploration parameter t0 > 0, parameter α > 0 2: for t = 1, 2, . . . , T do 3: p̂ij(t) :=
wij(t) nij(t) , p̂(i, i)← 1/2, ∀i, j ∈ [K] (assume x0 := 0.5, ∀x ∈ R) 4: Receive St ⊆ [K] 5: if |St| ≥ 2 and ∃i, j ∈ St s.t. nij(t) < t0, i 6= j then 6: Set xt ← i, yt ← j . Exploration rounds 7: else 8: B̂i(t) := {j ∈ [K] \ {i} | p̂ij(t) ≤ 1/2} ∩ St, ∀i ∈ [K] . Empirical winners over i 9: Ii(t) := ∑ j∈B̂i(t) nij(t) kl(p̂ij(t),
1/2), ∀i ∈ [K] and î∗t ← arg mini∈St Ii(t) 10: Ct := {i ∈ St | Ii(t)− Îi∗t (t) ≤ α log t} . Potential good arms 11: Select any xt from Ct uniformly at random 12: if ( î∗t ∈ B̂xt(t) or B̂xt(t) = ∅ ) : set yt ← î∗t , else: yt ← arg maxi∈St\{xt} p̂ixt(t) 13: end if 14: Play (xt, yt) Receive preference feedback ot 15: end for
Theorem 6 (Expected regret analysis SlDB-ED). Let t0 = 1 and α = 4K. Then as T → ∞, the expected regret incurred by SlDB-ED (Alg. 2) can be upper bounded as: For all ε2, . . . , εK ≥ 0 E [ RT ] . K2 +
∑ 1≤i<j≤K ( K1{∆(i,j)>εj} ∆(i, j)2 + nij(T ) min{εj ,∆(i, j)} ) + K∑ j=2
K log T max { εj ,∆(j − 1, j)+ } ≤ O ( min
{ K∑ j=2 K log T ∆(j − 1, j)+ , KT 2/3 }) .
The proof is deferred to Appendix 10. Although it borrows some high-level ideas from [19] for sleeping bandits and from [21] for RMED in standard dueling bandits, our analysis needed new ingredients in order to obtain O(K2(log T )/∆). This is especially the case for the proofs of the technical Lemmas 8 and 9 which significantly differ from “corresponding” technical lemmas of [21]. Specifically, both regret bounds of RMED and ours need to control the length of an initial exploration t0 after which pairwise preferences are well estimated by p̂ij(t). This is done respectively by our Lemma 8 and Lemma 5 of [21]. Yet, RMED’s original analysis is based on a union bound over all possible subsets S ⊂ {1, . . . ,K} of items (see Equation (19) in [21]), whose number is exponential in K. Despite our efforts, we could not follow the proof of Lemma 5 of [21], which to the best of our understanding, should yield to an exploration t0 exponentially large in K contrary to O(1) claimed in [21]. Instead, in our proof of Lem. 8, we carefully apply concentration inequalities to run union bounds over the items directly instead of sets of items.
The upper-bound of Thm. 6 is close to optimal. It suffers at most a suboptimal factor K and exactly matches the lower-bound for some problems. The distribution-free upper-bound of order O(T 2/3) matches obtainable standard dueling bandit problems [21, 37], since the latter algorithms also suffer constant terms of order ∆−2. Yet, it is unclear whether it is optimal or if O( √ T ) can be obtained.
Remark 3 (Sequence ST adaptivity of Alg. 2). It is worth pointing out that the regret bound of Thm. 6 is finite time and automatically adapts to the sequence of available sets ST . In the worst-case, the complexity lies in identifying for all items j the gap with the earlier item j − 1. Yet, our regretbound, which holds for any εj ≥ 0, will automatically perform a trade-off for each j between the gap ∆(j − 1, j)−1+ and εj ∑j−1 i=1 nij(T ) the number of times j is played together with a better item i < j.
In particular, ∑j−1 i=1 nij(T ) can be small if j is rarely available in St while not optimal. Notably, this adaptivity to ST item per item improves the regret guarantee of Thm. (10), [19], which also addresses the problem of sleeping bandits with ‘adversarial availabilities’ but for the stochastic multi-armed bandit setup and only provides worst-case guarantees over all ST and a trade-off ε independent of j. Remark 4 (SlDB-ED in standard dueling bandits). Even in the dueling bandit setting (without the sleeping component), SlDB-ED and Thm. 6 have advantages compared to the RMED algorithm and analysis of [21]. Our regret bound is valid for all number of items K, while the one of Thm. 3 of [21] is only asymptotic when K → ∞. This is due to the fact that the algorithm of [21] depends
on a hyper-parameter f(K) which needs to larger than AK, where A is a constant in K and T but which depends on the unknown sub-optimality gaps ∆(i, j). Thus, [21] chooses f(K) ≈ K1+ε so that eventually the bound is satisfied when K →∞. Instead, our algorithm only depends on easily tunable hyper-parameters t0 and α, whose optimal values are independent of unknown parameters.

heading: 6 Experiments
text: In this section, we compare the empirical performances of our two proposed algorithms (Alg. 1 and 2). Note that there are no other existing algorithms for our problem (see Sec. 1).
Constructing Preference Matrices (P). We use the following three different utility based PlackettLuce(θ) preference models (see Sec. 2) that ensures a total-ordering. We now construct three types of problem instances 1. Easy 2. Medium 3. Hard, for any given K, such that items with their respective θ parameters are assigned as follows: 1. Easy: θ(1 : bK/2c) = 1, θ(bK/2c + 1 : K) = 0.5. 2. Medium: θ(1 : bK/3c) = 1, θ(bK/3c+ 1 : b2K/3c) = 0.7, θ(b2K/3c+ 1 : K) = 0.4. 3. Hard: θ(i) = 1− (i− 1)/K, ∀i ∈ [K]. Note for each σ∗ = (1 > 2 > . . .K). In every experiment, we set the learning parameters α = 0.51, δ = 1/T for SlDB-UCB (Alg. 1) and as per Thm. 6 for SlDB-ED (Alg. 2). All results are averaged over 50 runs.
Regret over Varying Preference Matrices. We first plot the cumulative regret of our two algorithms (Alg. 1 and 2) over time on the above three Plackett-Luce datasets for K = 10. We generate availability sequence ST randomly by sampling every item i ∈ [K] independently with probability 0.5. Fig 2 shows that, as their names suggest too, instance-Easy is easiest to learn as the best-vs-worst item preferences are well separated and the diversity of the item preferences across different groups are least. Consequently the algorithms yield slightly more regret on instance-Medium due to higher preference diversity, and the hardest instance being Hard where the learner really needs to differentiate the ranking of every item for any arbitrary set sequences ST . Empirically SlDB-UCB is seen to slightly outperform SlDB-ED, though orderwise they perform competitively.
Regret over Varying Set Availabilities. In these set of experiments, the idea is to understand how the regret improves over completely random subset availabilities as now the learner may not have to distinguish all item preferences as some of the item combinations occurs rarely. We choose K = 10 and to enforce item dependencies we generate each set St by drawing a random sample from Gaussian(µ,Σ) such that µi = 0, ∀i ∈ [10], and Σ is a fixed 10× 10 positive definite matrix which controls the set dependencies: Precisely we use two different block diagonal matrices for Low-Correlation and High-Correlation with the following correlations: 1. Low-Correlation: Σ is a separated block diagonal matrix on item partitions {1, 2, 3}, {4, 5, 6}, {7, 8, 9, 10}. 2. HighCorrelation: Σ is constructed by merging three all-1 matrices on partitions {1 . . . 5}, {2, . . . 8}, and {6, . . . 10}, however as the resulting matrix is positive semi-definite, so we further take its SVD and reconstruct the matrix back eliminating the negative eigenvalues. At every round we sample a random vector from Gaussian(µ,Σ), and St is considered to be the set of items whose value exceeds 0.5. Both experiments are run on instance-Hard. Fig. 3 shows, as expected, on Low-Correlation both algorithms converge to σ∗ relatively faster and at lower regret compared to High-Correlation (as the latter induces higher variability of the available subsets).
Final Regret vs Setsize(K). We also compared the (averaged) final regret of the two algorithms over varying item sizes K. We additionally constructed two larger Plackett-Luce (θ) Easy and Hard instances for K = 20 and 40, using similar θ assignments explained before. We set T = 10 000 and use itemwise independent set generation idea, as described for Fig. 2. As expected, Fig. 4 shows the regret of both algorithms scales up with increasing K with effect on SlDB-ED being slightly worse than SlDB-UCB, though the latter generally exhibits a higher variance.
Worst Case Regret vs Time. We run an experiment to analyse the regret of our two algorithms on the worst case problem instances. Towards this we use preference matrices P∆ of the form: P∆(i, j) = 0.5 + ∆, ∀1 ≤ i < j ≤ K, i.e. all items are spaced with equidistant gap ∆ ∈ (0, 0.5]. As before, we choose T = 20, 000 and K = 10, and run the algorithms on above problem instances varying ∆ in the range [10/T, . . . , 0.5] with uniform grid-size of 0.005 (i.e. total 100 values of ∆, each corresponds to a separate problem instance P∆ with different ‘gap-complexity’). At the end we plot the worst case regret of both the algorithms over time, by plotting max∆Rt(P∆) vs t. We run the experiments over three availability sequences: 1. Independent (as used in Fig. 2), 2. Low-Correlation, and 3. High-Correlation (as used in Fig. 3). As a consequence the resulting plots reflect the worst case (w.r.t. ∆) performances of the algorithms, which seem to be scaling as O(T 2/3) for SlDB-ED, as conjectured to be its distribution free upper bound (see discussion after Thm. 6), and with a slightly lower rate for SlDB-UCB. Fig. 5 shows the comparative performances.

heading: 7 Conclusion and Perspective
text: We introduce the problem of sleeping dueling bandits with stochastic preferences and adversarial availabilities, which, despite of great practical relevance, was left unaddressed till date. Towards this we adapt two dueling bandit algorithms for the problem and give regret analysis for both. We also derive an instance dependent regret lower bound for our problem setup which shows that our second algorithm is asymptotically near-optimal (up to the problem dependent constants). Finally, we compare both our algorithms empirically where usually the first algorithm is shown to outperform the second, although having a relatively weaker regret.
Future Works. Moving forward, one can address many open questions along this direction, including relaxing the total-ordering assumption on the stochastic preferences assuming more general ranking objective based on borda [32] or copeland scores [36], or extending the framework to a general contextual scenario with subsetwise feedback. Another direction worth understanding is to analyze the connection of this problem with other bandit setups, e.g., learning with feedback graphs [3, 4] or other side information [23, 20]. It would also be interesting to consider the dueling bandit problem for adversarial preference and stochastic availabilities [24, 17], and also analyzing these class of problems for general subsetwise preferences [25, 30, 8].

Review summaries:
This paper studies a variant of the dueling bandit problem, where the availability of arms might differ for different time steps and consequently the learner might only choose pairs of arms from a subset of all existing arms. In other words, this variant is the preference-based counterpart of the sleeping bandit problem considered in the literature within the classical MAB problem with numerical rewards. Under the assumption of a total order of arms and a possibly adversarial availability of the arms, the authors show a finite-time lower bound on the expected regret. Further, they suggest two algorithms for this learning scenario: one is based on the well-known RUCB for the classical dueling bandit problem, for which high-probability regret bounds are obtained. The other is a modification of the well-known RMED algorithm, for which a finite-time expected regret bound is shown. The main contribution of the paper is thus the transfer of the sleeping aspect to the dueling bandits and the theoretical analysis of the resulting problem. 

This paper studies the sleeping dueling bandits with stochastic preferences and adversarial availabilities (DB-SPAA). The paper provides a lower bound for this problem, and proposes two algorithms with near optimal regret guarantees. Experimental results are shown to demonstrate the effectiveness of the proposed algorithms.

This paper studies the classic dueling bandits problem in the sleeping bandits setting, i.e. where each round an adversarially selected subset of actions is available. As in dueling bandits, each round the learner is allowed to choose two of the available actions, and learns a noisy signal about which action is better. We also assume there is a consistent total ordering of the items. The learner would like to minimize their total regret over T rounds compared to an algorithm which knows this ordering in advance.  This paper proves the following results: - They show an Omega(K^2 log T) (really Omega(log T * sum 1/gap_{i, j})) lower bound on the regret of any learning algorithm. - They then give an algorithm (S1DB-UCB) that matches this lower bound. The idea, roughly, is to maintain a confidence interval for each pair of items representing the probability that one beats the other. Each round, the algorithm picks one random element from the set of “potential winners” (roughly, items which have a chance of being the best item), and then a second item being the one with the highest UCB probability of beating the first item. - They give a slightly more computationally efficient algorithm (taking ~O(K) time per step instead of O(K^2) time per step) with a slightly worse regret bound. - Finally, they run some empirical simulations comparing the two above algorithms on synthetic data.