# Introduction to Multi-Armed Bandits
**Authors**:
- Aleksandrs Slivkins (Microsoft Research NYC)
subsection 1in1in* \setulmarginsandblock 1.3in1in*
Abstract
Multi-armed bandits a simple but very powerful framework for algorithms that make decisions over time under uncertainty. An enormous body of work has accumulated over the years, covered in several books and surveys. This book provides a more introductory, textbook-like treatment of the subject. Each chapter tackles a particular line of work, providing a self-contained, teachable technical introduction and a brief review of the further developments; many of the chapters conclude with exercises.
The book is structured as follows. The first four chapters are on IID rewards, from the basic model to impossibility results to Bayesian priors to Lipschitz rewards. The next three chapters cover adversarial rewards, from the full-feedback version to adversarial bandits to extensions with linear rewards and combinatorially structured actions. Chapter 8 is on contextual bandits, a middle ground between IID and adversarial bandits in which the change in reward distributions is completely explained by observable contexts. The last three chapters cover connections to economics, from learning in repeated games to bandits with supply/budget constraints to exploration in the presence of incentives. The appendix provides sufficient background on concentration and KL-divergence.
The chapters on âbandits with similarity informationâ, âbandits with knapsacksâ and âbandits and agentsâ can also be consumed as standalone surveys on the respective topics.
Published with Foundations and TrendsÂź in Machine Learning, November 2019.
This online version is a revision of the âFoundations and Trendsâ publication. It contains numerous edits for presentation and accuracy (based in part on readersâ feedback), some new exercises, and updated and expanded literature reviews. Further comments, suggestions and bug reports are very welcome!
$\copyright$ 2017-2024: Aleksandrs Slivkins. Authorâs webpage: https://www.microsoft.com/en-us/research/people/slivkins. Email: slivkins at microsoft.com.
| First draft: | January 2017 |
| --- | --- |
| Published: | November 2019 |
| Latest version: | April 2024 |
Preface
Multi-armed bandits is a rich, multi-disciplinary research area which receives attention from computer science, operations research, economics and statistics. It has been studied since (Thompson, 1933), with a big surge of activity in the past 15-20 years. An enormous body of work has accumulated over time, various subsets of which have been covered in several books (Berry and Fristedt, 1985; Cesa-Bianchi and Lugosi, 2006; Gittins et al., 2011; Bubeck and Cesa-Bianchi, 2012).
This book provides a more textbook-like treatment of the subject, based on the following principles. The literature on multi-armed bandits can be partitioned into a dozen or so lines of work. Each chapter tackles one line of work, providing a self-contained introduction and pointers for further reading. We favor fundamental ideas and elementary proofs over the strongest possible results. We emphasize accessibility of the material: while exposure to machine learning and probability/statistics would certainly help, a standard undergraduate course on algorithms, e.g., one based on (Kleinberg and Tardos, 2005), should suffice for background. With the above principles in mind, the choice specific topics and results is based on the authorâs subjective understanding of what is important and âteachableâ, i.e., presentable in a relatively simple manner. Many important results has been deemed too technical or advanced to be presented in detail.
The book is based on a graduate course at University of Maryland, College Park, taught by the author in Fall 2016. Each chapter corresponds to a week of the course. Five chapters were used in a similar course at Columbia University, co-taught by the author in Fall 2017. Some of the material has been updated since then, to improve presentation and reflect the latest developments.
To keep the book manageable, and also more accessible, we chose not to dwell on the deep connections to online convex optimization. A modern treatment of this fascinating subject can be found, e.g., in Shalev-Shwartz (2012); Hazan (2015). Likewise, we do not venture into reinforcement learning, a rapidly developing research area and subject of several textbooks such as Sutton and Barto (1998); SzepesvĂĄri (2010); Agarwal et al. (2020). A course based on this book would be complementary to graduate-level courses on online convex optimization and reinforcement learning. Also, we do not discuss Markovian models of multi-armed bandits; this direction is covered in depth in Gittins et al. (2011).
The author encourages colleagues to use this book in their courses. A brief email regarding which chapters have been used, along with any feedback, would be appreciated.
A simultaneous book. An excellent recent book on bandits, Lattimore and SzepesvĂĄri (2020), has evolved over several years simultaneously and independently with mine. Their book is longer, provides deeper treatment for some topics (esp. for adversarial and linear bandits), and omits some others (e.g., Lipschitz bandits, bandits with knapsacks, and connections to economics). Reflecting the authorsâ differing tastes and presentation styles, the two books are complementary to one another.
Acknowledgements. Most chapters originated as lecture notes from my course at UMD; the initial versions of these lectures were scribed by the students. Presentation of some of the fundamental results is influenced by (Kleinberg, 2007). I am grateful to Alekh Agarwal, Bobby Kleinberg, Akshay Krishnamurthy, Yishay Mansour, John Langford, Thodoris Lykouris, Rob Schapire, and Mark Sellke for discussions, comments, and advice. Chapters 9, 10 have benefited tremendously from numerous conversations with Karthik Abinav Sankararaman. Special thanks go to my PhD advisor Jon Kleinberg and my postdoc mentor Eli Upfal; Jon has shaped my taste in research, and Eli has introduced me to multi-armed bandits back in 2006. Finally, I wish to thank my parents and my family for love, inspiration and support. Contents
1. Introduction: Scope and Motivation
1. 1 Stochastic Bandits
1. 1 Model and examples
1. 2 Simple algorithms: uniform exploration
1. 2.1 Improvement: Epsilon-greedy algorithm
1. 2.2 Non-adaptive exploration
1. 3 Advanced algorithms: adaptive exploration
1. 3.1 Clean event and confidence bounds
1. 3.2 Successive Elimination algorithm
1. 3.3 Optimism under uncertainty
1. 4 Forward look: bandits with initial information
1. 5 Literature review and discussion
1. 6 Exercises and hints
1. 2 Lower Bounds
1. 7 Background on KL-divergence
1. 8 A simple example: flipping one coin
1. 9 Flipping several coins: âbest-arm identificationâ
1. 10 Proof of Lemma 2.8 for the general case
1. 11 Lower bounds for non-adaptive exploration
1. 12 Instance-dependent lower bounds (without proofs)
1. 13 Literature review and discussion
1. 14 Exercises and hints
1. 3 Bayesian Bandits and Thompson Sampling
1. 15 Bayesian update in Bayesian bandits
1. 15.1 Terminology and notation
1. 15.2 Posterior does not depend on the algorithm
1. 15.3 Posterior as a new prior
1. 15.4 Independent priors
1. 16 Algorithm specification and implementation
1. 16.1 Computational aspects
1. 17 Bayesian regret analysis
1. 18 Thompson Sampling with no prior (and no proofs)
1. 19 Literature review and discussion
1. 4 Bandits with Similarity Information
1. 20 Continuum-armed bandits
1. 20.1 Simple solution: fixed discretization
1. 20.2 Lower Bound
1. 21 Lipschitz bandits
1. 21.1 Brief background on metric spaces
1. 21.2 Uniform discretization
1. 22 Adaptive discretization: the Zooming Algorithm
1. 22.1 Algorithm
1. 22.2 Analysis: clean event
1. 22.3 Analysis: bad arms
1. 22.4 Analysis: covering numbers and regret
1. 23 Literature review and discussion
1. 23.1 Further results on Lipschitz bandits
1. 23.2 Partial similarity information
1. 23.3 Generic non-Lipschitz models for bandits with similarity
1. 23.4 Dynamic pricing and bidding
1. 24 Exercises and hints
1. 24.1 Construction of $\epsilon$ -meshes
1. 24.2 Lower bounds for uniform discretization
1. 24.3 Examples and extensions
1. 24.4 Dynamic pricing
1. 5 Full Feedback and Adversarial Costs
1. 25 Setup: adversaries and regret
1. 26 Initial results: binary prediction with experts advice
1. 27 Hedge Algorithm
1. 28 Literature review and discussion
1. 29 Exercises and hints
1. 6 Adversarial Bandits
1. 30 Reduction from bandit feedback to full feedback
1. 31 Adversarial bandits with expert advice
1. 32 Preliminary analysis: unbiased estimates
1. 33 Algorithm $\mathtt{Exp4}$ and crude analysis
1. 34 Improved analysis of $\mathtt{Exp4}$
1. 35 Literature review and discussion
1. 35.1 Refinements for the âstandardâ notion of regret
1. 35.2 Stronger notions of regret
1. 36 Exercises and hints
1. 7 Linear Costs and Semi-Bandits
1. 37 Online routing problem
1. 38 Combinatorial semi-bandits
1. 39 Online Linear Optimization: Follow The Perturbed Leader
1. 40 Literature review and discussion
1. 8 Contextual Bandits
1. 41 Warm-up: small number of contexts
1. 42 Lipshitz contextual bandits
1. 43 Linear contextual bandits (no proofs)
1. 44 Contextual bandits with a policy class
1. 45 Learning from contextual bandit data
1. 46 Contextual bandits in practice: challenges and a system design
1. 47 Literature review and discussion
1. 48 Exercises and hints
1. 9 Bandits and Games
1. 49 Basics: guaranteed minimax value
1. 50 The minimax theorem
1. 51 Regret-minimizing adversary
1. 52 Beyond zero-sum games: coarse correlated equilibrium
1. 53 Literature review and discussion
1. 53.1 Zero-sum games
1. 53.2 Beyond zero-sum games
1. 54 Exercises and hints
1. 10 Bandits with Knapsacks
1. 55 Definitions, examples, and discussion
1. 56 Examples
1. 57 LagrangeBwK: a game-theoretic algorithm for $\mathtt{BwK}$
1. 58 Optimal algorithms and regret bounds (no proofs)
1. 59 Literature review and discussion
1. 59.1 Reductions from $\mathtt{BwK}$ to bandits
1. 59.2 Extensions of $\mathtt{BwK}$
1. 59.3 Beyond the worst case
1. 59.4 Adversarial bandits with knapsacks
1. 59.5 Paradigmaric application: Dynamic pricing with limited supply
1. 59.6 Rewards vs. costs
1. 60 Exercises and hints
1. 11 Bandits and Agents
1. 61 Problem formulation: incentivized exploration
1. 62 How much information to reveal?
1. 63 Basic technique: hidden exploration
1. 64 Repeated hidden exploration
1. 65 A necessary and sufficient assumption on the prior
1. 66 Literature review and discussion: incentivized exploration
1. 67 Literature review and discussion: other work on bandits and agents
1. 67.1 Repeated auctions: agents choose bids
1. 67.2 Contract design: agents (only) affect rewards
1. 67.3 Agents choose between bandit algorithms
1. 68 Exercises and hints
1. 12 Concentration inequalities
1. 13 Properties of KL-divergence
*
Introduction: Scope and Motivation
Multi-armed bandits is a simple but very powerful framework for algorithms that make decisions over time under uncertainty. Let us outline some of the problems that fall under this framework.
We start with three running examples, concrete albeit very stylized:
News website
When a new user arrives, a website site picks an article header to show, observes whether the user clicks on this header. The siteâs goal is maximize the total number of clicks. Dynamic pricing
A store is selling a digital good, e.g., an app or a song. When a new customer arrives, the store chooses a price offered to this customer. The customer buys (or not) and leaves forever. The storeâs goal is to maximize the total profit. Investment
Each morning, you choose one stock to invest into, and invest $1. In the end of the day, you observe the change in value for each stock. The goal is to maximize the total wealth.
Multi-armed bandits unifies these examples (and many others). In the basic version, an algorithm has $K$ possible actions to choose from, a.k.a. arms, and $T$ rounds. In each round, the algorithm chooses an arm and collects a reward for this arm. The reward is drawn independently from some distribution which is fixed (i.e., depends only on the chosen arm), but not known to the algorithm. Going back to the running examples:
| Example | Action | Reward |
| --- | --- | --- |
| News website | an article to display | $1$ if clicked, $0$ otherwise |
| Dynamic pricing | a price to offer | $p$ if sale, $0$ otherwise |
| Investment | a stock to invest into | change in value during the day |
In the basic model, an algorithm observes the reward for the chosen arm after each round, but not for the other arms that could have been chosen. Therefore, the algorithm typically needs to explore: try out different arms to acquire new information. Indeed, if an algorithm always chooses arm $1$ , how would it know if arm $2$ is better? Thus, we have a tradeoff between exploration and exploitation: making optimal near-term decisions based on the available information. This tradeoff, which arises in numerous application scenarios, is essential in multi-armed bandits. Essentially, the algorithm strives to learn which arms are best (perhaps approximately so), while not spending too much time exploring.
The term âmulti-armed banditsâ comes from a stylized gambling scenario in which a gambler faces several slot machines, a.k.a. one-armed bandits, that appear identical, but yield different payoffs.
Multi-dimensional problem space
Multi-armed bandits is a huge problem space, with many âdimensionsâ along which the models can be made more expressive and closer to reality. We discuss some of these modeling dimensions below. Each dimension gave rise to a prominent line of work, discussed later in this book.
Auxiliary feedback. What feedback is available to the algorithm after each round, other than the reward for the chosen arm? Does the algorithm observe rewards for the other arms? Letâs check our examples:
| Example | Auxiliary feedback | Rewards for any other arms? |
| --- | --- | --- |
| News website | N/A | no (bandit feedback). |
| Dynamic pricing | sale $\Rightarrow$ sale at any lower price, | yes, for some arms, |
| no sale $\Rightarrow$ no sale at any higher price | but not for all (partial feedback). | |
| Investment | change in value for all other stocks | yes, for all arms (full feedback). |
We distinguish three types of feedback: bandit feedback, when the algorithm observes the reward for the chosen arm, and no other feedback; full feedback, when the algorithm observes the rewards for all arms that could have been chosen; and partial feedback, when some information is revealed, in addition to the reward of the chosen arm, but it does not always amount to full feedback.
This book mainly focuses on problems with bandit feedback. We also cover some of the fundamental results on full feedback, which are essential for developing subsequent bandit results. Partial feedback sometimes arises in extensions and special cases, and can be used to improve performance.
Rewards model. Where do the rewards come from? Several alternatives has been studied:
- IID rewards: the reward for each arm is drawn independently from a fixed distribution that depends on the arm but not on the round $t$ .
- Adversarial rewards: rewards can be arbitrary, as if they are chosen by an âadversaryâ that tries to fool the algorithm. The adversary may be oblivious to the algorithmâs choices, or adaptive thereto.
- Constrained adversary: rewards are chosen by an adversary that is subject to some constraints, e.g., reward of each arm cannot change much from one round to another, or the reward of each arm can change at most a few times, or the total change in rewards is upper-bounded.
- Random-process rewards: an armâs state, which determines rewards, evolves over time as a random process, e.g., a random walk or a Markov chain. The state transition in a particular round may also depend on whether the arm is chosen by the algorithm.
Contexts. In each round, an algorithm may observe some context before choosing an action. Such context often comprises the known properties of the current user, and allows for personalized actions.
| Example | Context |
| --- | --- |
| News website | user location and demographics |
| Dynamic pricing | customerâs device (e.g., cell or laptop), location, demographics |
| Investment | current state of the economy. |
Reward now depends on both the context and the chosen arm. Accordingly, the algorithmâs goal is to find the best policy which maps contexts to arms.
Bayesian priors. In the Bayesian approach, the problem instance comes from a known distribution, called the Bayesian prior. One is typically interested in provable guarantees in expectation over this distribution.
Structured rewards. Rewards may have a known structure, e.g., arms correspond to points in $\mathbb{R}^{d}$ , and in each round the reward is a linear (resp., concave or Lipschitz) function of the chosen arm.
Global constraints. The algorithm can be subject to global constraints that bind across arms and across rounds. For example, in dynamic pricing there may be a limited inventory of items for sale.
Structured actions. An algorithm may need to make several decisions at once, e.g., a news website may need to pick a slate of articles, and a seller may need to choose prices for the entire slate of offerings.
Application domains
Multi-armed bandit problems arise in a variety of application domains. The original application has been the design of âethicalâ medical trials, so as to attain useful scientific data while minimizing harm to the patients. Prominent modern applications concern the Web: from tuning the look and feel of a website, to choosing which content to highlight, to optimizing web search results, to placing ads on webpages. Recommender systems can use exploration to improve its recommendations for movies, restaurants, hotels, and so forth. Another cluster of applications pertains to economics: a seller can optimize its prices and offerings; likewise, a frequent buyer such as a procurement agency can optimize its bids; an auctioneer can adjust its auction over time; a crowdsourcing platform can improve the assignment of tasks, workers and prices. In computer systems, one can experiment and learn, rather than rely on a rigid design, so as to optimize datacenters and networking protocols. Finally, one can teach a robot to better perform its tasks.
| Application domain | Action | Reward |
| --- | --- | --- |
| medical trials | which drug to prescribe | health outcome. |
| web design | e.g., font color or page layout | #clicks. |
| content optimization | which items/articles to emphasize | #clicks. |
| web search | search results for a given query | #satisfied users. |
| advertisement | which ad to display | revenue from ads. |
| recommender systems | e.g., which movie to watch | $1$ if follows recommendation. |
| sales optimization | which products to offer at which prices | revenue. |
| procurement | which items to buy at which prices | #items procured |
| auction/market design | e.g., which reserve price to use | revenue |
| crowdsourcing | match tasks and workers, assign prices | #completed tasks |
| datacenter design | e.g., which server to route the job to | job completion time. |
| Internet | e.g., which TCP settings to use? | connection quality. |
| radio networks | which radio frequency to use? | #successful transmissions. |
| robot control | a âstrategyâ for a given task | job completion time. |
(Brief) bibliographic notes
Medical trials has a major motivation for introducing multi-armed bandits and exploration-exploitation tradeoff (Thompson, 1933; Gittins, 1979). Bandit-like designs for medical trials belong to the realm of adaptive medical trials (Chow and Chang, 2008), which can also include other âadaptiveâ features such as early stopping, sample size re-estimation, and changing the dosage.
Applications to the Web trace back to (Pandey et al., 2007a, b; Langford and Zhang, 2007) for ad placement, (Li et al., 2010, 2011) for news optimization, and (Radlinski et al., 2008) for web search. A survey of the more recent literature is beyond our scope. Bandit algorithms tailored to recommendation systems are studied, e.g., in (Bresler et al., 2014; Li et al., 2016; Bresler et al., 2016).
Applications to problems in economics comprise many aspects: optimizing sellerâs prices, a.k.a. dynamic pricing or learn-and-earn, (Boer, 2015, a survey); optimizing sellerâs product offerings, a.k.a. dynamic assortment (e.g., SaurĂ© and Zeevi, 2013; Agrawal et al., 2019); optimizing buyers prices, a.k.a. dynamic procurement (e.g., Badanidiyuru et al., 2012, 2018); design of auctions (e.g., Bergemann and Said, 2011; Cesa-Bianchi et al., 2013; Babaioff et al., 2015b); design of information structures (Kremer et al., 2014, starting from), and design of crowdsourcing platforms (Slivkins and Vaughan, 2013, a survey).
Applications of bandits to Internet routing and congestion control were started in theory, starting with (Awerbuch and Kleinberg, 2008; Awerbuch et al., 2005), and in systems (Dong et al., 2015, 2018; Jiang et al., 2016, 2017). Bandit problems directly motivated by radio networks have been studied starting from (Lai et al., 2008; Liu and Zhao, 2010; Anandkumar et al., 2011).
Chapter 1 Stochastic Bandits
This chapter covers bandits with IID rewards, the basic model of multi-arm bandits. We present several algorithms, and analyze their performance in terms of regret. The ideas introduced in this chapter extend far beyond the basic model, and will resurface throughout the book.
Prerequisites: Hoeffding inequality (Appendix 12).
1 Model and examples
We consider the basic model with IID rewards, called stochastic bandits. Here and elsewhere, IID stands for âindependent and identically distributedâ. An algorithm has $K$ possible actions to choose from, a.k.a. arms, and there are $T$ rounds, for some known $K$ and $T$ . In each round, the algorithm chooses an arm and collects a reward for this arm. The algorithmâs goal is to maximize its total reward over the $T$ rounds. We make three essential assumptions:
- The algorithm observes only the reward for the selected action, and nothing else. In particular, it does not observe rewards for other actions that could have been selected. This is called bandit feedback.
- The reward for each action is IID. For each action $a$ , there is a distribution $\mathcal{D}_{a}$ over reals, called the reward distribution. Every time this action is chosen, the reward is sampled independently from this distribution. The reward distributions are initially unknown to the algorithm.
- Per-round rewards are bounded; the restriction to the interval $[0,1]$ is for simplicity.
Thus, an algorithm interacts with the world according to the protocol summarized below.
Problem protocol: Stochastic bandits
Parameters: $K$ arms, $T$ rounds (both known); reward distribution $\mathcal{D}_{a}$ for each arm $a$ (unknown).
In each round $tâ[T]$ :
- Algorithm picks some arm $a_{t}$ .
- Reward $r_{t}â[0,1]$ is sampled independently from distribution $\mathcal{D}_{a}$ , $a=a_{t}$ .
- Algorithm collects reward $r_{t}$ , and observes nothing else.
We are primarily interested in the mean reward vector $\muâ[0,1]^{K}$ , where $\mu(a)=\operatornamewithlimits{\mathbb{E}}[\mathcal{D}_{a}]$ is the mean reward of arm $a$ . Perhaps the simplest reward distribution is the Bernoulli distribution, when the reward of each arm $a$ can be either 1 or 0 (âsuccess or failureâ, âheads or tailsâ). This reward distribution is fully specified by the mean reward, which in this case is simply the probability of the successful outcome. The problem instance is then fully specified by the time horizon $T$ and the mean reward vector.
Our model is a simple abstraction for an essential feature of reality that is present in many application scenarios. We proceed with three motivating examples:
1. News: in a very stylized news application, a user visits a news site, the site presents a news header, and a user either clicks on this header or not. The goal of the website is to maximize the number of clicks. So each possible header is an arm in a bandit problem, and clicks are the rewards. Each user is drawn independently from a fixed distribution over users, so that in each round the click happens independently with a probability that depends only on the chosen header.
1. Ad selection: In website advertising, a user visits a webpage, and a learning algorithm selects one of many possible ads to display. If ad $a$ is displayed, the website observes whether the user clicks on the ad, in which case the advertiser pays some amount $v_{a}â[0,1]$ . So each ad is an arm, and the paid amount is the reward. The $v_{a}$ depends only on the displayed ad, but does not change over time. The click probability for a given ad does not change over time, either.
1. Medical Trials: a patient visits a doctor and the doctor can prescribe one of several possible treatments, and observes the treatment effectiveness. Then the next patient arrives, and so forth. For simplicity of this example, the effectiveness of a treatment is quantified as a number in $[0,1]$ . Each treatment can be considered as an arm, and the reward is defined as the treatment effectiveness. As an idealized assumption, each patient is drawn independently from a fixed distribution over patients, so the effectiveness of a given treatment is IID.
Note that the reward of a given arm can only take two possible values in the first two examples, but could, in principle, take arbitrary values in the third example.
**Remark 1.1**
*We use the following conventions in this chapter and throughout much of the book. We will use arms and actions interchangeably. Arms are denoted with $a$ , rounds with $t$ . There are $K$ arms and $T$ rounds. The set of all arms is $\mathcal{A}$ . The mean reward of arm $a$ is $\mu(a):=\operatornamewithlimits{\mathbb{E}}[\mathcal{D}_{a}]$ . The best mean reward is denoted $\mu^{*}:=\max_{aâ\mathcal{A}}\mu(a)$ . The difference $\Delta(a):=\mu^{*}-\mu(a)$ describes how bad arm $a$ is compared to $\mu^{*}$ ; we call it the gap of arm $a$ . An optimal arm is an arm $a$ with $\mu(a)=\mu^{*}$ ; note that it is not necessarily unique. We take $a^{*}$ to denote some optimal arm. $[n]$ denotes the set $\{1,2\,,\ ...\ ,n\}$ .*
Regret. How do we argue whether an algorithm is doing a good job across different problem instances? The problem is, some problem instances inherently allow higher rewards than others. One standard approach is to compare the algorithmâs cumulative reward to the best-arm benchmark $\mu^{*}· T$ : the expected reward of always playing an optimal arm, which is the best possible total expected reward for a particular problem instance. Formally, we define the following quantity, called regret at round $T$ :
$$
\displaystyle\textstyle R(T)=\mu^{*}\cdot T-\sum_{t=1}^{T}\mu(a_{t}). \tag{1}
$$
Indeed, this is how much the algorithm âregretsâ not knowing the best arm in advance. Note that $a_{t}$ , the arm chosen at round $t$ , is a random quantity, as it may depend on randomness in rewards and/or in the algorithm. So, $R(T)$ is also a random variable. We will typically talk about expected regret $\operatornamewithlimits{\mathbb{E}}[R(T)]$ .
We mainly care about the dependence of $\operatornamewithlimits{\mathbb{E}}[R(T)]$ regret on the time horizon $T$ . We also consider the dependence on the number of arms $K$ and the mean rewards $\mu(·)$ . We are less interested in the fine-grained dependence on the reward distributions (beyond the mean rewards). We will usually use big-O notation to focus on the asymptotic dependence on the parameters of interests, rather than keep track of the constants.
**Remark 1.2 (Terminology)**
*Since our definition of regret sums over all rounds, we sometimes call it cumulative regret. When/if we need to highlight the distinction between $R(T)$ and $\operatornamewithlimits{\mathbb{E}}[R(T)]$ , we say realized regret and expected regret; but most of the time we just say âregretâ and the meaning is clear from the context. The quantity $R(T)$ is sometimes called pseudo-regret in the literature.*
2 Simple algorithms: uniform exploration
We start with a simple idea: explore arms uniformly (at the same rate), regardless of what has been observed previously, and pick an empirically best arm for exploitation. A natural incarnation of this idea, known as Explore-first algorithm, is to dedicate an initial segment of rounds to exploration, and the remaining rounds to exploitation.
1 Exploration phase: try each arm $N$ times;
2 Select the arm $\hat{a}$ with the highest average reward (break ties arbitrarily);
Exploitation phase: play arm $\hat{a}$ in all remaining rounds.
Algorithm 1 Explore-First with parameter $N$ .
The parameter $N$ is fixed in advance; it will be chosen later as function of the time horizon $T$ and the number of arms $K$ , so as to minimize regret. Let us analyze regret of this algorithm.
Let the average reward for each action $a$ after exploration phase be denoted $\bar{\mu}(a)$ . We want the average reward to be a good estimate of the true expected rewards, i.e. the following quantity should be small: $|\bar{\mu}(a)-\mu(a)|$ . We bound it using the Hoeffding inequality (Theorem 12.1):
$$
\displaystyle\Pr\left[\,|\bar{\mu}(a)-\mu(a)|\leq\mathtt{rad}\,\right]\geq 1-\nicefrac{{2}}{{T^{4}}}\text{,~~where }\mathtt{rad}:=\sqrt{2\log(T)\,/\,N}. \tag{2}
$$
**Remark 1.3**
*Thus, $\mu(a)$ lies in the known interval $[\bar{\mu}(a)-\mathtt{rad},\bar{\mu}(a)+\mathtt{rad}]$ with high probability. A known interval containing some scalar quantity is called the confidence interval for this quantity. Half of this intervalâs length (in our case, $\mathtt{rad}$ ) is called the confidence radius. It is called a âradiusâ because an interval can be seen as a âballâ on the real line.*
We define the clean event to be the event that (2) holds for all arms simultaneously. We will argue separately the clean event, and the âbad eventâ â the complement of the clean event.
**Remark 1.4**
*With this approach, one does not need to worry about probability in the rest of the analysis. Indeed, the probability has been taken care of by defining the clean event and observing that (2) holds therein. We do not need to worry about the bad event, either: essentially, because its probability is so tiny. We will use this âclean eventâ approach in many other proofs, to help simplify the technical details. This simplicity usually comes at the cost of slightly larger constants in $O()$ , compared to more careful arguments which explicitly track low-probability events throughout the proof.*
For simplicity, let us start with the case of $K=2$ arms. Consider the clean event. We will show that if we chose the worse arm, it is not so bad because the expected rewards for the two arms would be close.
Let the best arm be $a^{*}$ , and suppose the algorithm chooses the other arm $aâ a^{*}$ . This must have been because its average reward was better than that of $a^{*}$ : $\bar{\mu}(a)>\bar{\mu}(a^{*})$ . Since this is a clean event, we have:
| | $\displaystyle\mu(a)+\mathtt{rad}â„\bar{\mu}(a)>\bar{\mu}(a^{*})â„\mu(a^{*})-\mathtt{rad}$ | |
| --- | --- | --- |
Re-arranging the terms, it follows that $\mu(a^{*})-\mu(a)†2\,\mathtt{rad}.$
Thus, each round in the exploitation phase contributes at most $2\,\mathtt{rad}$ to regret. Each round in exploration trivially contributes at most $1$ . We derive an upper bound on the regret, which consists of two parts: for exploration, when each arm is chosen $N$ times, and then for the remaining $T-2N$ rounds of exploitation:
| | $\displaystyle R(T)†N+2\,\mathtt{rad}·(T-2N)<N+2\,\mathtt{rad}· T.$ | |
| --- | --- | --- |
Recall that we can select any value for $N$ , as long as it is given to the algorithm in advance. So, we can choose $N$ so as to (approximately) minimize the right-hand side. Since the two summands are, resp., monotonically increasing and monotonically decreasing in $N$ , we can set $N$ so that they are approximately equal. For $N=T^{2/3}\,(\log T)^{1/3}$ , we obtain:
| | $\displaystyle R(T)$ | $\displaystyle†O\left(T^{2/3}\;(\log T)^{1/3}\right).$ | |
| --- | --- | --- | --- |
It remains to analyze the âbad eventâ. Since regret can be at most $T$ (each round contributes at most $1$ ), and the bad event happens with a very small probability, regret from this event can be neglected. Formally:
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}\left[\,R(T)\,\right] \displaystyle=\operatornamewithlimits{\mathbb{E}}\left[\,R(T)\mid\text{clean event}\,\right]\times\Pr\left[\,\text{clean event}\,\right]\;+\;\operatornamewithlimits{\mathbb{E}}\left[\,R(T)\mid\text{bad event}\,\right]\times\Pr\left[\,\text{bad event}\,\right] \displaystyle\leq\operatornamewithlimits{\mathbb{E}}\left[\,R(T)\mid\text{clean event}\,\right]+T\times O\left(\,T^{-4}\,\right) \displaystyle\leq O\left(\,(\log T)^{1/3}\times T^{2/3}\,\right). \tag{3}
$$
This completes the proof for $K=2$ arms.
For $K>2$ arms, we apply the union bound for (2) over the $K$ arms, and then follow the same argument as above. Note that $T℠K$ without loss of generality, since we need to explore each arm at least once. For the final regret computation, we will need to take into account the dependence on $K$ : specifically, regret accumulated in exploration phase is now upper-bounded by $KN$ . Working through the proof, we obtain $R(T)†NK+2\,\mathtt{rad}· T$ . As before, we approximately minimize it by approximately minimizing the two summands. Specifically, we plug in $N=(T/K)^{2/3}· O(\log T)^{1/3}$ . Completing the proof same way as in (3), we obtain:
**Theorem 1.5**
*Explore-first achieves regret $\operatornamewithlimits{\mathbb{E}}\left[\,R(T)\,\right]†T^{2/3}à O(K\log T)^{1/3}$ .*
2.1 Improvement: Epsilon-greedy algorithm
One problem with Explore-first is that its performance in the exploration phase may be very bad if many/most of the arms have a large gap $\Delta(a)$ . It is usually better to spread exploration more uniformly over time. This is done in the Epsilon-greedy algorithm:
for each round $t=1,2,...$ do
Toss a coin with success probability $\epsilon_{t}$ ;
if success then
explore: choose an arm uniformly at random
else
exploit: choose the arm with the highest average reward so far
end for
Algorithm 2 Epsilon-Greedy with exploration probabilities $(\epsilon_{1},\epsilon_{2},...)$ .
Choosing the best option in the short term is often called the âgreedyâ choice in the computer science literature, hence the name âEpsilon-greedyâ. The exploration is uniform over arms, which is similar to the âround-robinâ exploration in the explore-first algorithm. Since exploration is now spread uniformly over time, one can hope to derive meaningful regret bounds even for small $t$ . We focus on exploration probability $\epsilon_{t}\sim t^{-1/3}$ (ignoring the dependence on $K$ and $\log t$ for a moment), so that the expected number of exploration rounds up to round $t$ is on the order of $t^{2/3}$ , same as in Explore-first with time horizon $T=t$ . We derive the same regret bound as in Theorem 1.5, but now it holds for all rounds $t$ .
**Theorem 1.6**
*Epsilon-greedy algorithm with exploration probabilities $\epsilon_{t}=t^{-1/3}·(K\log t)^{1/3}$ achieves regret bound $\operatornamewithlimits{\mathbb{E}}[R(t)]†t^{2/3}· O(K\log t)^{1/3}$ for each round $t$ .*
The proof relies on a more refined clean event, introduced in the next section; we leave it as Exercise 1.2.
2.2 Non-adaptive exploration
Explore-first and Epsilon-greedy do not adapt their exploration schedule to the history of the observed rewards. We refer to this property as non-adaptive exploration, and formalize it as follows:
**Definition 1.7**
*A round $t$ is an exploration round if the data $\left(\,a_{t},r_{t}\,\right)$ from this round is used by the algorithm in the future rounds. A deterministic algorithm satisfies non-adaptive exploration if the set of all exploration rounds and the choice of arms therein is fixed before round $1$ . A randomized algorithm satisfies non-adaptive exploration if it does so for each realization of its random seed.*
Next, we obtain much better regret bounds by adapting exploration to the observations. Non-adaptive exploration is indeed the key obstacle here. Making this point formal requires information-theoretic machinery developed in Chapter 2; see Section 11 for the precise statements.
3 Advanced algorithms: adaptive exploration
We present two algorithms which achieve much better regret bounds. Both algorithms adapt exploration to the observations so that very under-performing arms are phased out sooner.
Letâs start with the case of $K=2$ arms. One natural idea is as follows:
$$
\displaystyle\text{alternate the arms until we are confident which arm is better, and play this arm thereafter}. \tag{4}
$$
However, how exactly do we determine whether and when we are confident? We flesh this out next.
3.1 Clean event and confidence bounds
Fix round $t$ and arm $a$ . Let $n_{t}(a)$ be the number of rounds before $t$ in which this arm is chosen, and let $\bar{\mu}_{t}(a)$ be the average reward in these rounds. We will use Hoeffding Inequality (Theorem 12.1) to derive
$$
\displaystyle\Pr\left[\,|\bar{\mu}_{t}(a)-\mu(a)|\leq r_{t}(a)\,\right]\geq 1-\tfrac{2}{T^{4}}\text{,~~where }r_{t}(a)=\sqrt{2\log(T)\,/\,n_{t}(a)}. \tag{5}
$$
However, Eq. (5) does not follow immediately. This is because Hoeffding Inequality only applies to a fixed number of independent random variables, whereas here we have $n_{t}(a)$ random samples from reward distribution $\mathcal{D}_{a}$ , where $n_{t}(a)$ is itself is a random variable. Moreover, $n_{t}(a)$ can depend on the past rewards from arm $a$ , so conditional on a particular realization of $n_{t}(a)$ , the samples from $a$ are not necessarily independent! For a simple example, suppose an algorithm chooses arm $a$ in the first two rounds, chooses it again in round $3$ if and only if the reward was $0$ in the first two rounds, and never chooses it again.
So, we need a slightly more careful argument. We present an elementary version of this argument (whereas a more standard version relies on the concept of martingale). For each arm $a$ , let us imagine there is a reward tape: an $1Ă T$ table with each cell independently sampled from $\mathcal{D}_{a}$ , as shown in Figure 1.
<details>
<summary>figures/ch-IID-tape.png Details</summary>
### Visual Description
# Technical Document Extraction: Array/Sequence Diagram
## 1. Image Overview
The image is a technical diagram representing a sequential data structure or a series of time steps, likely used in the context of signal processing, statistics, or machine learning. It illustrates a process of averaging values across a subset of a sequence.
## 2. Component Isolation
### Region A: Main Sequence (Top)
The primary visual element is a horizontal rectangular bar divided into six distinct segments (cells). Each cell contains a text label at the top center.
| Cell Position (Left to Right) | Text Label | Description |
| :--- | :--- | :--- |
| 1 | $1^{\text{st}}$ cell | The initial element of the sequence. |
| 2 | $2^{\text{nd}}$ cell | The second element of the sequence. |
| 3 | $\dots$ | Ellipsis indicating omitted intermediate cells. |
| 4 | j-th cell | An arbitrary $j$-th element in the sequence. |
| 5 | $\dots$ | Ellipsis indicating further omitted intermediate cells. |
| 6 | T-th cell | The final element of the sequence, where $T$ represents the total length. |
### Region B: Annotation (Bottom)
Below the main sequence, there is a grouping indicator and a mathematical label.
* **Bracket:** A light blue curly brace (bracket) spans horizontally beneath the first four cells (from the "$1^{\text{st}}$ cell" to the "j-th cell").
* **Label:** Centered beneath the bracket is the text: **"averages to $\bar{v}_j(a)$"**.
## 3. Technical Interpretation and Logic
* **Sequence Structure:** The diagram represents a discrete sequence of length $T$.
* **Spatial Grounding:** The bracket is anchored at the left edge of the first cell and extends to the right edge of the $j$-th cell.
* **Mathematical Operation:** The diagram indicates that the values contained within the first $j$ cells are being aggregated. Specifically, the label "averages to $\bar{v}_j(a)$" suggests that the mean of the elements from index $1$ to $j$ is calculated, and the resulting value is denoted by the variable $\bar{v}_j(a)$.
* **Variable Notation:**
* $\bar{v}$ typically denotes an average or mean value.
* The subscript $j$ indicates the cumulative nature of the average (up to the $j$-th element).
* The $(a)$ likely refers to a specific parameter, action, or state associated with the data.
## 4. Summary of Data Points
* **Total Elements:** $T$
* **Index of Interest:** $j$
* **Range of Operation:** $[1, j]$
* **Resultant Value:** $\bar{v}_j(a)$
</details>
Figure 1: the $j$ -th cell contains the reward of the $j$ -th time we pull arm $a$ , i.e., reward of arm $a$ when $n_{t}(a)=j$
Without loss of generality, the reward tape encodes rewards as follows: the $j$ -th time a given arm $a$ is chosen by the algorithm, its reward is taken from the $j$ -th cell in this armâs tape. Let $\bar{v}_{j}(a)$ represent the average reward at arm $a$ from first $j$ times that arm $a$ is chosen. Now one can use Hoeffding Inequality to derive that
$$
\forall j\quad\Pr\left[\,|\bar{v}_{j}(a)-\mu(a)|\leq r_{t}(a)\,\right]\geq 1-\nicefrac{{2}}{{T^{4}}}.
$$
Taking a union bound, it follows that (assuming $K=\text{\#arms}†T$ )
$$
\displaystyle\Pr\left[\,\mathcal{E}\,\right]\geq 1-\nicefrac{{2}}{{T^{2}}}\text{,~~where }\mathcal{E}:=\left\{\,\forall a\forall t\quad|\bar{\mu}_{t}(a)-\mu(a)|\leq r_{t}(a)\,\right\}. \tag{6}
$$
The event $\mathcal{E}$ in (6) will be the clean event for the subsequent analysis.
For each arm $a$ at round $t$ , we define upper and lower confidence bounds,
| | $\displaystyle\mathtt{UCB}_{t}(a)$ | $\displaystyle=\bar{\mu}_{t}(a)+r_{t}(a),$ | |
| --- | --- | --- | --- |
As per Remark 1.3, we have confidence interval $\left[\,\mathtt{LCB}_{t}(a),\mathtt{UCB}_{t}(a)\,\right]$ and confidence radius $r_{t}(a)$ .
3.2 Successive Elimination algorithm
Letâs come back to the case of $K=2$ arms, and recall the idea (4). Now we can naturally implement this idea via the confidence bounds. The full algorithm for two arms is as follows:
Alternate two arms until $\mathtt{UCB}_{t}(a)<\mathtt{LCB}_{t}(a^{\prime})$ after some even round $t$ ;
Abandon arm $a$ , and use arm $a^{\prime}$ forever since.
Algorithm 3 âHigh-confidence eliminationâ algorithm for two arms
For analysis, assume the clean event. Note that the âabandonedâ arm cannot be the best arm. But how much regret do we accumulate before disqualifying one arm?
Let $t$ be the last round when we did not invoke the stopping rule, i.e., when the confidence intervals of the two arms still overlap (see Figure 2). Then Î:=â ÎŒ (a) - ÎŒ (aâ)ââ€2(r_t(a) + r_t(aâ)).
<details>
<summary>figures/ch-IID-last_round.png Details</summary>
### Visual Description
# Technical Document Extraction: Upper Confidence Bound (UCB) Overlap Diagram
## 1. Image Overview
This image is a technical diagram illustrating the relationship between confidence intervals for two different actions (denoted as $a$ and $a'$) in the context of a Multi-Armed Bandit problem or a similar reinforcement learning algorithm. It specifically visualizes the "last round they overlap," representing the boundary condition for regret or sub-optimality.
## 2. Component Isolation
### Region A: Upper Confidence Interval (Action $a'$)
* **Location:** Top-center of the image.
* **Visual Element:** A vertical black line with double-headed arrows. A solid black dot is positioned in the center of this line.
* **Top Label:** $UCB_t(a')$ (Upper Confidence Bound for action $a'$ at time $t$).
* **Left Annotation:** A light blue curly bracket spans the length of this vertical line, labeled with the text:
> $\mu_t(a')$
> somewhere
> here
* **Interpretation:** This represents the estimated mean and uncertainty range for action $a'$.
### Region B: Lower Confidence Interval (Action $a$)
* **Location:** Bottom-center of the image, slightly offset to the left of the upper interval.
* **Visual Element:** A vertical black line with double-headed arrows. A solid black dot is positioned in the center of this line.
* **Bottom Label:** $LCB_t(a)$ (Lower Confidence Bound for action $a$ at time $t$).
* **Left Annotation:** A light blue curly bracket spans the length of this vertical line, labeled with the text:
> $\mu_t(a)$
> somewhere
> here
* **Interpretation:** This represents the estimated mean and uncertainty range for action $a$.
### Region C: Interaction Boundary
* **Visual Element:** A horizontal dashed blue line.
* **Alignment:** This line aligns exactly with the **bottom** arrow of the $UCB_t(a')$ interval and the **top** arrow of the $LCB_t(a)$ interval.
* **Text Label (Above Line):** "last round they overlap"
* **Interpretation:** This indicates the point where the upper bound of the lower action meets the lower bound of the higher action.
### Region D: Total Range Scale
* **Location:** Far right side of the image.
* **Visual Element:** A large, light blue curly bracket spanning the entire vertical distance from the top of $UCB_t(a')$ to the bottom of $LCB_t(a)$.
* **Right Label:** $2(r_t(a) + r_t(a'))$
* **Interpretation:** This defines the total vertical distance of the combined confidence intervals as twice the sum of the radii (confidence widths) of the two actions.
## 3. Mathematical and Logical Flow
The diagram illustrates a critical state in exploration-exploitation algorithms:
1. **Action $a'$** is currently estimated to have a higher mean than **Action $a$**.
2. The uncertainty (represented by the vertical lines) shows that the true means ($\mu$) could be anywhere within those brackets.
3. The **"last round they overlap"** occurs when the lower bound of the superior action's estimate meets the upper bound of the inferior action's estimate.
4. The total distance between the highest possible value ($UCB_t(a')$) and the lowest possible value ($LCB_t(a)$) is quantified as $2(r_t(a) + r_t(a'))$, where $r_t$ represents the confidence radius or "bonus" added to the empirical mean.
## 4. Text Transcription Summary
| Label/Text | Context |
| :--- | :--- |
| $UCB_t(a')$ | Top boundary of the upper interval. |
| $\mu_t(a')$ somewhere here | Description of the possible true mean for action $a'$. |
| last round they overlap | Description of the horizontal dashed line where intervals meet. |
| $2(r_t(a) + r_t(a'))$ | Total vertical span of both intervals combined. |
| $\mu_t(a)$ somewhere here | Description of the possible true mean for action $a$. |
| $LCB_t(a)$ | Bottom boundary of the lower interval. |
</details>
Figure 2: $t$ is the last round that the two confidence intervals still overlap
Since the algorithm has been alternating the two arms before time $t$ , we have $n_{t}(a)=\nicefrac{{t}}{{2}}$ (up to floor and ceiling), which yields
$$
\Delta\leq 2\left(\,r_{t}(a)+r_{t}(a^{\prime})\,\right)\leq 4\sqrt{2\log(T)\,/\,{\lfloor{t/2}\rfloor}}=O\left(\,\sqrt{\log(T)\,/\,t}\,\right).
$$
Then the total regret accumulated till round $t$ is
$$
R(t)\leq\Delta\times t\leq O\left(\,t\cdot\sqrt{\tfrac{\log{T}}{t}}\,\right)=O\left(\,\sqrt{t\log{T}}\,\right).
$$
Since weâve chosen the best arm from then on, we have $R(t)†O\left(\,\sqrt{t\log{T}}\,\right)$ . To complete the analysis, we need to argue that the âbad eventâ $\bar{}\mathcal{E}$ contributes a negligible amount to regret, like in (3):
| | $\displaystyle\operatornamewithlimits{\mathbb{E}}\left[\,R(t)\,\right]$ | $\displaystyle=\operatornamewithlimits{\mathbb{E}}\left[\,R(t)\mid\text{clean event}\,\right]Ă\Pr\left[\,\text{clean event}\,\right]\;+\;\operatornamewithlimits{\mathbb{E}}\left[\,R(t)\mid\text{bad event}\,\right]Ă\Pr\left[\,\text{bad event}\,\right]$ | |
| --- | --- | --- | --- |
We proved the following:
**Lemma 1.8**
*For two arms, Algorithm 3 achieves regret $\operatornamewithlimits{\mathbb{E}}\left[\,R(t)\,\right]†O\left(\,\sqrt{t\log T}\,\right)$ for each round $t†T$ .*
**Remark 1.9**
*The $\sqrt{t}$ dependence in this regret bound should be contrasted with the $T^{2/3}$ dependence for Explore-First. This improvement is possible due to adaptive exploration.*
This approach extends to $K>2$ arms as follows: alternate the arms until some arm $a$ is worse than some other arm with high probability. When this happens, discard all such arms $a$ and go to the next phase. This algorithm is called Successive Elimination.
All arms are initially designated as active
loop {new phase}
play each active arm once
deactivate all arms $a$ such that, letting $t$ be the current round,
$\mathtt{UCB}_{t}(a)<\mathtt{LCB}_{t}(a^{\prime})$ for some other arm $a^{\prime}$ {deactivation rule}
end loop
Algorithm 4 Successive Elimination
To analyze the performance of this algorithm, it suffices to focus on the clean event (6); as in the case of $K=2$ arms, the contribution of the âbad eventâ $\bar{}\mathcal{E}$ can be neglected.
Let $a^{*}$ be an optimal arm, and note that it cannot be deactivated. Fix any arm $a$ such that $\mu(a)<\mu(a^{*})$ . Consider the last round $t†T$ when deactivation rule was invoked and arm $a$ remained active. As in the argument for $K=2$ arms, the confidence intervals of $a$ and $a^{*}$ must overlap at round $t$ . Therefore,
| | $\displaystyle\Delta(a):=\mu(a^{*})-\mu(a)$ | $\displaystyle†2\left(\,r_{t}(a^{*})+r_{t}(a)\,\right)=4· r_{t}(a).$ | |
| --- | --- | --- | --- |
The last equality is because $n_{t}(a)=n_{t}(a^{*})$ , since the algorithm has been alternating active arms and both $a$ and $a^{*}$ have been active before round $t$ . By the choice of $t$ , arm $a$ can be played at most once afterwards: $n_{T}(a)†1+n_{t}(a)$ . Thus, we have the following crucial property:
$$
\displaystyle\Delta(a)\leq O(r_{T}(a))=O\left(\,\sqrt{\left.\log(T)\right/n_{T}(a)}\,\right)\quad\text{for each arm $a$ with $\mu(a)<\mu(a^{*})$}. \tag{7}
$$
Informally: an arm played many times cannot be too bad. The rest of the analysis only relies on (7). In other words, it does not matter which algorithm achieves this property.
The contribution of arm $a$ to regret at round $t$ , denoted $R(t;a)$ , can be expressed as $\Delta(a)$ for each round this arm is played; by (7) we can bound this quantity as
$$
R(t;a)=n_{t}(a)\cdot\Delta(a)\leq n_{t}(a)\cdot O\left(\sqrt{\log(T)\,/\,n_{t}(a)}\right)=O\left(\,\sqrt{n_{t}(a)\log{T}}\,\right).
$$
Summing up over all arms, we obtain that
$$
\displaystyle\textstyle R(t)=\sum_{a\in\mathcal{A}}R(t;a)\leq O\left(\,\sqrt{\log T}\,\right)\sum_{a\in\mathcal{A}}\sqrt{n_{t}(a)}. \tag{8}
$$
Since $f(x)=\sqrt{x}$ is a real concave function, and $\sum_{aâ\mathcal{A}}n_{t}(a)=t$ , by Jensenâs Inequality we have
$$
\frac{1}{K}\sum_{a\in\mathcal{A}}\sqrt{n_{t}(a)}\leq\sqrt{\frac{1}{K}\sum_{a\in\mathcal{A}}n_{t}(a)}=\sqrt{\frac{t}{K}}.
$$
Plugging this into (8), we see that $R(t)†O\left(\,\sqrt{Kt\log{T}}\,\right)$ . Thus, we have proved:
**Theorem 1.10**
*Successive Elimination algorithm achieves regret
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}\left[\,R(t)\,\right]=O\left(\,\sqrt{Kt\log T}\,\right)\quad\text{for all rounds $t\leq T$}. \tag{9}
$$*
We can also use property (7) to obtain another regret bound. Rearranging the terms in (7), we obtain $n_{T}(a)†O\left(\,\log(T)\,/\,[\Delta(a)]^{2}\,\right)$ . In words, a bad arm cannot be played too often. So,
$$
\displaystyle R(T;a)=\Delta(a)\cdot n_{T}(a)\leq\Delta(a)\cdot O\left(\,\frac{\log{T}}{[\Delta(a)]^{2}}\,\right)=O\left(\,\frac{\log{T}}{\Delta(a)}\,\right). \tag{10}
$$
Summing up over all suboptimal arms, we obtain the following theorem.
**Theorem 1.11**
*Successive Elimination algorithm achieves regret
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}[R(T)]\leq O(\log{T})\left[\,\sum_{\text{arms $a$ with $\mu(a)<\mu(a^{*})$}}\frac{1}{\mu(a^{*})-\mu(a)}\,\right]. \tag{11}
$$*
This regret bound is logarithmic in $T$ , with a constant that can be arbitrarily large depending on a problem instance. In particular, this constant is at most $O(\nicefrac{{K}}{{\Delta}})$ , where
$$
\displaystyle\Delta \displaystyle=\min_{\text{suboptimal arms $a$}}\Delta(a) \displaystyle\text{\emph{(minimal gap)}}. \tag{12}
$$
The distinction between regret bounds achievable with an absolute constant (as in Theorem 1.10) and regret bounds achievable with an instance-dependent constant is typical for multi-armed bandit problems. The existence of logarithmic regret bounds is another benefit of adaptive exploration.
**Remark 1.12**
*For a more formal terminology, consider a regret bound of the form $C· f(T)$ , where $f(·)$ does not depend on the mean reward vector $\mu$ , and the âconstantâ $C$ does not depend on $T$ . Such regret bound is called instance-independent if $C$ does not depend on $\mu$ , and instance-dependent otherwise.*
**Remark 1.13**
*It is instructive to derive Theorem 1.10 in a different way: starting from the logarithmic regret bound in (10). Informally, we need to get rid of arbitrarily small gaps $\Delta(a)$ in the denominator. Let us fix some $\epsilon>0$ , then regret consists of two parts:
- all arms $a$ with $\Delta(a)â€\epsilon$ contribute at most $\epsilon$ per round, for a total of $\epsilon T$ ;
- each arm $a$ with $\Delta(a)>\epsilon$ contributes $R(T;a)†O\left(\,\frac{1}{\epsilon}\log T\,\right)$ , under the clean event.
Combining these two parts and assuming the clean event, we see that
$$
R(T)\leq O\left(\epsilon T+\tfrac{K}{\epsilon}\log{T}\right).
$$
Since this holds for any $\epsilon>0$ , we can choose one that minimizes the right-hand side. Ensuring that $\epsilon T=\frac{K}{\epsilon}\log{T}$ yields $\epsilon=\sqrt{\frac{K}{T}\log{T}}$ , and therefore $R(T)†O\left(\,\sqrt{KT\log T}\,\right)$ .*
3.3 Optimism under uncertainty
Let us consider another approach for adaptive exploration, known as optimism under uncertainty: assume each arm is as good as it can possibly be given the observations so far, and choose the best arm based on these optimistic estimates. This intuition leads to the following simple algorithm called $\mathtt{UCB1}$ :
Try each arm once
for each round $t=1\,,\ ...\ ,T$ do
pick arm some $a$ which maximizes $\mathtt{UCB}_{t}(a)$ .
end for
Algorithm 5 Algorithm $\mathtt{UCB1}$
**Remark 1.14**
*Letâs see why UCB-based selection rule makes sense. An arm $a$ can have a large $\mathtt{UCB}_{t}(a)$ for two reasons (or combination thereof): because the average reward $\bar{\mu}_{t}(a)$ is large, in which case this arm is likely to have a high reward, and/or because the confidence radius $r_{t}(a)$ is large, in which case this arm has not been explored much. Either reason makes this arm worth choosing. Put differently, the two summands in $\mathtt{UCB}_{t}(a)=\bar{\mu}_{t}(a)+r_{t}(a)$ represent, resp., exploitation and exploration, and summing them up is one natural way to resolve exploration-exploitation tradeoff.*
To analyze this algorithm, let us focus on the clean event (6), as before. Recall that $a^{*}$ is an optimal arm, and $a_{t}$ is the arm chosen by the algorithm in round $t$ . According to the algorithm, $\mathtt{UCB}_{t}(a_{t})â„\mathtt{UCB}_{t}(a^{*})$ . Under the clean event, $\mu(a_{t})+r_{t}(a_{t})â„\bar{\mu}_{t}(a_{t})$ and $\mathtt{UCB}_{t}(a^{*})â„\mu(a^{*})$ . Therefore:
$$
\displaystyle\mu(a_{t})+2r_{t}(a_{t})\geq\bar{\mu}_{t}(a_{t})+r_{t}(a_{t})=\mathtt{UCB}_{t}(a_{t})\geq\mathtt{UCB}_{t}(a^{*})\geq\mu(a^{*}). \tag{13}
$$
It follows that
$$
\displaystyle\Delta(a_{t}):=\mu(a^{*})-\mu(a_{t})\leq 2r_{t}(a_{t})=2\sqrt{2\log(T)\,/\,n_{t}(a_{t})}. \tag{14}
$$
This cute trick resurfaces in the analyses of several UCB-like algorithms for more general settings.
For each arm $a$ consider the last round $t$ when this arm is chosen by the algorithm. Applying (14) to this round gives us property (7). The rest of the analysis follows from that property, as in the analysis of Successive Elimination.
**Theorem 1.15**
*Algorithm $\mathtt{UCB1}$ satisfies regret bounds in (9) and (11).*
4 Forward look: bandits with initial information
Some information about the mean reward vector $\mu$ may be known to the algorithm beforehand, and may be used to improve performance. This âinitial informationâ is typically specified via a constraint on $\mu$ or a Bayesian prior thereon. In particular, such models may allow for non-trivial regret bounds that are independent of the number of arms, and hold even for infinitely many arms.
Constrained mean rewards. The canonical modeling approach embeds arms into $\mathbb{R}^{d}$ , for some fixed $dâ\mathbb{N}$ . Thus, arms correspond to points in $\mathbb{R}^{d}$ , and $\mu$ is a function on (a subset of) $\mathbb{R}^{d}$ which maps arms to their respective mean rewards. The constraint is that $\mu$ belongs to some family $\mathcal{F}$ of âwell-behavedâ functions. Typical assumptions are:
- linear functions: $\mu(a)=w· a$ for some fixed but unknown vector $wâ\mathbb{R}^{d}$ .
- concave functions: the set of arms is a convex subset in $\mathbb{R}^{d}$ , $\mu^{\prime\prime}(·)$ exists and is negative.
- Lipschitz functions: $|\mu(a)-\mu(a^{\prime})|†L·\|a-a^{\prime}\|_{2}$ for all arms $a,a^{\prime}$ and some fixed constant $L$ .
Such assumptions introduce dependence between arms, so that one can infer something about the mean reward of one arm by observing the rewards of some other arms. In particular, Lipschitzness allows only âlocalâ inferences: one can learn something about arm $a$ only by observing other arms that are not too far from $a$ . In contrast, linearity and concavity allow âlong-rangeâ inferences: one can learn about arm $a$ by observing arms that lie very far from $a$ .
One usually proves regret bounds that hold for each $\muâ\mathcal{F}$ . A typical regret bound allows for infinitely many arms, and only depends on the time horizon $T$ and the dimension $d$ . The drawback is that such results are only as good as the worst case over $\mathcal{F}$ . This may be overly pessimistic if the âbadâ problem instances occur very rarely, or overly optimistic if $\muâ\mathcal{F}$ is itself a very strong assumption.
Bayesian bandits. Here, $\mu$ is drawn independently from some distribution $\mathbb{P}$ , called the Bayesian prior. One is interested in Bayesian regret: regret in expectation over $\mathbb{P}$ . This is special case of the Bayesian approach, which is very common in statistics and machine learning: an instance of the model is sampled from a known distribution, and performance is measured in expectation over this distribution.
The prior $\mathbb{P}$ implicitly defines the family $\mathcal{F}$ of feasible mean reward vectors (i.e., the support of $\mathbb{P}$ ), and moreover specifies whether and to which extent some mean reward vectors in $\mathcal{F}$ are more likely than others. The main drawbacks are that the sampling assumption may be very idealized in practice, and the âtrueâ prior may not be fully known to the algorithm.
5 Literature review and discussion
This chapter introduces several techniques that are broadly useful in multi-armed bandits, beyond the specific setting discussed in this chapter. These are the four algorithmic techniques (Explore-first, Epsilon-greedy, Successive Elimination, and UCB-based arm selection), the âclean eventâ technique in the analysis, and the âUCB trickâ from (13). Successive Elimination is from Even-Dar et al. (2002), and $\mathtt{UCB1}$ is from Auer et al. (2002a). Explore-first and Epsilon-greedy algorithms have been known for a long time; it is unclear what the original references are. The original version of $\mathtt{UCB1}$ has confidence radius
$$
\displaystyle r_{t}(a)=\sqrt{\alpha\cdot\ln(t)\,/\,n_{t}(a)} \tag{15}
$$
with $\alpha=2$ ; note that $\log T$ is replaced with $\log t$ compared to the exposition in this chapter (see (5)). This version allows for the same regret bounds, at the cost of a somewhat more complicated analysis.
Optimality. Regret bounds in (9) and (11) are near-optimal, according to the lower bounds which we discuss in Chapter 2. The instance-dependent regret bound in (9) is optimal up to $O(\log T)$ factors. Audibert and Bubeck (2010) shave off the $\log T$ factor, obtaining an instance dependent regret bound $O(\sqrt{KT})$ .
The logarithmic regret bound in (11) is optimal up to constant factors. A line of work strived to optimize the multiplicative constant in $O()$ . Auer et al. (2002a); Bubeck (2010); Garivier and Cappé (2011) analyze this constant for $\mathtt{UCB1}$ , and eventually improve it to $\frac{1}{2\ln 2}$ . More precisely, Garivier and Cappé (2011) derive the constant $\frac{\alpha}{2\ln 2}$ , using confidence radius (15) with any $\alpha>1$ . The original analysis in Auer et al. (2002a) obtained constant $\frac{8}{\ln 2}$ using $\alpha=2$ . This factor is the best possible in view of the lower bound in Section 12. Further, (Audibert et al., 2009; Honda and Takemura, 2010; Garivier and Cappé, 2011; Maillard et al., 2011) refine the $\mathtt{UCB1}$ algorithm and obtain regret bounds that are at least as good as those for $\mathtt{UCB1}$ , and get better for some reward distributions.
High-probability regret. In order to upper-bound expected regret $\operatornamewithlimits{\mathbb{E}}[R(T)]$ , we actually obtained a high-probability upper bound on $R(T)$ . This is common for regret bounds obtained via the âclean eventâ technique. However, high-probability regret bounds take substantially more work in some of the more advanced bandit scenarios, e.g., for adversarial bandits (see Chapter 6).
Regret for all rounds at once. What if the time horizon $T$ is not known in advance? Can we achieve similar regret bounds that hold for all rounds $t$ , not just for all $t†T$ ? Recall that in Successive Elimination and $\mathtt{UCB1}$ , knowing $T$ was needed only to define the confidence radius $r_{t}(a)$ . There are several remedies:
- If an upper bound on $T$ is known, one can use it instead of $T$ in the algorithm. Since our regret bounds depend on $T$ only logarithmically, rather significant over-estimates can be tolerated.
- Use $\mathtt{UCB1}$ with confidence radius $r_{t}(a)=\sqrt{\frac{2\log{t}}{n_{t}(a)}}$ , as in (Auer et al., 2002a). This version does not input $T$ , and its regret analysis works for an arbitrary $T$ .
- Any algorithm for known time horizon can (usually) be converted to an algorithm for an arbitrary time horizon using the doubling trick. Here, the new algorithm proceeds in phases of exponential duration. Each phase $i=1,2,...$ lasts $2^{i}$ rounds, and executes a fresh run of the original algorithm. This approach achieves the ârightâ theoretical guarantees (see Exercise 1.5). However, forgetting everything after each phase is not very practical.
Instantaneous regret. An alternative notion of regret considers each round separately: instantaneous regret at round $t$ (also called simple regret) is defined as $\Delta(a_{t})=\mu^{*}-\mu(a_{t})$ , where $a_{t}$ is the arm chosen in this round. In addition to having low cumulative regret, it may be desirable to spread the regret more âuniformlyâ over rounds, so as to avoid spikes in instantaneous regret. Then one would also like an upper bound on instantaneous regret that decreases monotonically over time. See Exercise 1.3.
Bandits with predictions. While the standard goal for bandit algorithms is to maximize cumulative reward, an alternative goal is to output a prediction $a^{*}_{t}$ after each round $t$ . The algorithm is then graded only on the quality of these predictions. In particular, it does not matter how much reward is accumulated. There are two standard ways to formalize this objective: (i) minimize instantaneous regret $\mu^{*}-\mu(a^{*}_{t})$ , and (ii) maximize the probability of choosing the best arm: $\Pr[a^{*}_{t}=a^{*}]$ . The former is called pure-exploration bandits, and the latter is called best-arm identification. Essentially, good algorithms for cumulative regret, such as Successive Elimination and $\mathtt{UCB1}$ , are also good for this version (more on this in Exercises 1.3 and 1.4). However, improvements are possible in some regimes (e.g., Mannor and Tsitsiklis, 2004; Even-Dar et al., 2006; Bubeck et al., 2011a; Audibert et al., 2010). See Exercise 1.4.
Available arms. What if arms are not always available to be selected by the algorithm? The sleeping bandits model in Kleinberg et al. (2008a) allows arms to âfall asleepâ, i.e., become unavailable. Earlier work (Freund et al., 1997; Blum, 1997) studied this problem under full feedback. Accordingly, the benchmark is not the best fixed arm, which may be asleep at some rounds, but the best fixed ranking of arms: in each round, the benchmark selects the highest-ranked arm that is currently âawakeâ. In the mortal bandits model in Chakrabarti et al. (2008), arms become permanently unavailable, according to a (possibly randomized) schedule that is known to the algorithm. Versions of $\mathtt{UCB1}$ works well for both models.
Partial feedback. Alternative models of partial feedback has been studied. In dueling bandits (Yue et al., 2012; Yue and Joachims, 2009), numeric reward is unavailable to the algorithm. Instead, one can choose two arms for a âduelâ, and find out whose reward in this round is larger. Motivation comes from web search optimization. When actions correspond to slates of search results, a numerical reward would only be a crude approximation of user satisfaction. However, one can measure which of the two slates is better in a much more reliable way using an approach called interleaving, see survey (Hofmann et al., 2016) for background. Further work on this model includes (Ailon et al., 2014; Zoghi et al., 2014; DudĂk et al., 2015).
Another model, termed partial monitoring (BartĂłk et al., 2014; Antos et al., 2013), posits that the outcome for choosing an arm $a$ is a (reward, feedback) pair, where the feedback can be an arbitrary message. Under the IID assumption, the outcome is chosen independently from some fixed distribution $D_{a}$ over the possible outcomes. So, the feedback could be more than bandit feedback, e.g., it can include the rewards of some other arms, or less than bandit feedback, e.g., it might only reveal whether or not the reward is greater than $0$ , while the reward could take arbitrary values in $[0,1]$ . A special case is when the structure of the feedback is defined by a graph on vertices, so that the feedback for choosing arm $a$ includes the rewards for all arms adjacent to $a$ (Alon et al., 2013, 2015).
Relaxed benchmark. If there are too many arms (and no helpful additional structure), then perhaps competing against the best arm is perhaps too much to ask for. But suppose we relax the benchmark so that it ignores the best $\epsilon$ -fraction of arms, for some fixed $\epsilon>0$ . We are interested in regret relative to the best remaining arm, call it $\epsilon$ -regret for brevity. One can think of $\frac{1}{\epsilon}$ as an effective number of arms. Accordingly, weâd like a bound on $\epsilon$ -regret that depends on $\frac{1}{\epsilon}$ , but not on the actual number of arms $K$ . Kleinberg (2006) achieves $\epsilon$ -regret of the form $\frac{1}{\epsilon}· T^{2/3}·\operatornamewithlimits{polylog}(T)$ . (The algorithm is very simple, based on a version on the âdoubling trickâ described above, although the analysis is somewhat subtle.) This result allows the $\epsilon$ -fraction to be defined relative to an arbitrary âbase distributionâ on arms, and extends to infinitely many arms. It is unclear whether better regret bounds are possible for this setting.
Bandits with initial information. Bayesian Bandits, Lipschitz bandits and Linear bandits are covered in Chapter 3, Chapter 4 and Chapter 7, respectively. Bandits with concave rewards / convex costs require fairly advanced techniques, and are not covered in this book. This direction has been initiated in Kleinberg (2004); Flaxman et al. (2005), with important recent advances (Hazan and Levy, 2014; Bubeck et al., 2015, 2017). A comprehensive treatment of this subject can be found in (Hazan, 2015).
6 Exercises and hints
All exercises below are fairly straightforward given the material in this chapter.
**Exercise 1.1 (rewards from a small interval)**
*Consider a version of the problem in which all the realized rewards are in the interval $\left[\,\nicefrac{{1}}{{2}},\nicefrac{{1}}{{2}}+\epsilon\,\right]$ for some $\epsilonâ(0,\nicefrac{{1}}{{2}})$ . Define versions of $\mathtt{UCB1}$ and Successive Elimination attain improved regret bounds (both logarithmic and root-T) that depend on the $\epsilon$ . Hint: Use a version of Hoeffding Inequality with ranges.*
**Exercise 1.2 (Epsilon-greedy)**
*Prove Theorem 1.6: derive the $O(t^{2/3})·(K\log t)^{1/3}$ regret bound for the epsilon-greedy algorithm exploration probabilities $\epsilon_{t}=t^{-1/3}·(K\log t)^{1/3}$ . Hint: Fix round $t$ and analyze $\operatornamewithlimits{\mathbb{E}}\left[\,\Delta(a_{t})\,\right]$ for this round separately. Set up the âclean eventâ for rounds $1\,,\ ...\ ,t$ much like in Section 3.1 (treating $t$ as the time horizon), but also include the number of exploration rounds up to time $t$ .*
**Exercise 1.3 (instantaneous regret)**
*Recall that instantaneous regret at round $t$ is $\Delta(a_{t})=\mu^{*}-\mu(a_{t})$ . - Prove that Successive Elimination achieves âinstance-independentâ regret bound of the form
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}\left[\,\Delta(a_{t})\,\right]\leq\frac{\operatornamewithlimits{polylog}(T)}{\sqrt{t/K}}\quad\text{for each round $t\in[T]$}. \tag{16}
$$
- Derive an âinstance-independentâ upper bound on instantaneous regret of Explore-first.*
**Exercise 1.4 (pure exploration)**
*Recall that in âpure-exploration banditsâ, after $T$ rounds the algorithm outputs a prediction: a guess $y_{T}$ for the best arm. We focus on the instantaneous regret $\Delta(y_{T})$ for the prediction. - Take any bandit algorithm with an instance-independent regret bound $E[R(T)]†f(T)$ , and construct an algorithm for âpure-exploration banditsâ such that $\operatornamewithlimits{\mathbb{E}}[\Delta(y_{T})]†f(T)/T$ .
Note: Surprisingly, taking $y_{T}=a_{t}$ does not seem to work in general â definitely not immediately. Taking $y_{T}$ to be the arm with a maximal empirical reward does not seem to work, either. But there is a simple solution âŠ
Take-away: We can easily obtain $\operatornamewithlimits{\mathbb{E}}[\Delta(y_{T})]=O(\sqrt{K\log(T)/T}$ from standard algorithms such as $\mathtt{UCB1}$ and Successive Elimination. However, as parts (bc) show, one can do much better!
- Consider Successive Elimination with $y_{T}=a_{T}$ . Prove that (with a slightly modified definition of the confidence radius) this algorithm can achieve
| | $\displaystyle\operatornamewithlimits{\mathbb{E}}\left[\,\Delta(y_{T})\,\right]†T^{-\gamma}\quad\text{if $T>T_{\mu,\gamma}$},$ | |
| --- | --- | --- |
where $T_{\mu,\gamma}$ depends only on the mean rewards $\mu(a):aâ\mathcal{A}$ and the $\gamma$ . This holds for an arbitrarily large constant $\gamma$ , with only a multiplicative-constant increase in regret.
Hint: Put the $\gamma$ inside the confidence radius, so as to make the âfailure probabilityâ sufficiently low.
- Prove that alternating the arms (and predicting the best one) achieves, for any fixed $\gamma<1$ :
| | $\displaystyle\operatornamewithlimits{\mathbb{E}}\left[\,\Delta(y_{T})\,\right]†e^{-\Omega(T^{\gamma})}\quad\text{if $T>T_{\mu,\gamma}$},$ | |
| --- | --- | --- |
where $T_{\mu,\gamma}$ depends only on the mean rewards $\mu(a):aâ\mathcal{A}$ and the $\gamma$ .
Hint: Consider Hoeffding Inequality with an arbitrary constant $\alpha$ in the confidence radius. Pick $\alpha$ as a function of the time horizon $T$ so that the failure probability is as small as needed.*
**Exercise 1.5 (Doubling trick)**
*Take any bandit algorithm $\mathcal{A}$ for fixed time horizon $T$ . Convert it to an algorithm $\mathcal{A}_{â}$ which runs forever, in phases $i=1,2,3,\,...$ of $2^{i}$ rounds each. In each phase $i$ algorithm $\mathcal{A}$ is restarted and run with time horizon $2^{i}$ . - State and prove a theorem which converts an instance-independent upper bound on regret for $\mathcal{A}$ into similar bound for $\mathcal{A}_{â}$ (so that this theorem applies to both $\mathtt{UCB1}$ and Explore-first).
- Do the same for $\log(T)$ instance-dependent upper bounds on regret. (Then regret increases by a $\log(T)$ factor.)*
Chapter 2 Lower Bounds
This chapter is about what bandit algorithms cannot do. We present several fundamental results which imply that the regret rates in Chapter 1 are essentially the best possible.
Prerequisites: Chapter 1 (minimally: the model and the theorem statements).
We revisit the setting of stochastic bandits from Chapter 1 from a different perspective: we ask what bandit algorithms cannot do. We are interested in lower bounds on regret which apply to all bandit algorithms at once. Rather than analyze a particular bandit algorithm, we show that any bandit algorithm cannot achieve a better regret rate. We prove that any algorithm suffers regret $\Omega(\sqrt{KT})$ on some problem instance. Then we use the same technique to derive stronger lower bounds for non-adaptive exploration. Finally, we formulate and discuss the instance-dependent $\Omega(\log T)$ lower bound (albeit without a proof). These fundamental lower bounds elucidate what are the best possible upper bounds that one can hope to achieve.
The $\Omega(\sqrt{KT})$ lower bound is stated as follows:
**Theorem 2.1**
*Fix time horizon $T$ and the number of arms $K$ . For any bandit algorithm, there exists a problem instance such that $\operatornamewithlimits{\mathbb{E}}[R(T)]â„\Omega(\sqrt{KT})$ .*
This lower bound is âworst-caseâ, leaving open the possibility that a particular bandit algorithm has low regret for many/most other problem instances. To prove such a lower bound, one needs to construct a family $\mathcal{F}$ of problem instances that can âfoolâ any algorithm. Then there are two standard ways to proceed:
- prove that any algorithm has high regret on some instance in $\mathcal{F}$ ,
- define a distribution over problem instances in $\mathcal{F}$ , and prove that any algorithm has high regret in expectation over this distribution.
**Remark 2.2**
*Note that (ii) implies (i), is because if regret is high in expectation over problem instances, then there exists at least one problem instance with high regret. Conversely, (i) implies (ii) if $|\mathcal{F}|$ is a constant: indeed, if we have high regret $H$ for some problem instance in $\mathcal{F}$ , then in expectation over a uniform distribution over $\mathcal{F}$ regret is least $H/|\mathcal{F}|$ . However, this argument breaks if $|\mathcal{F}|$ is large. Yet, a stronger version of (i) which says that regret is high for a constant fraction of the instances in $\mathcal{F}$ implies (ii), with uniform distribution over the instances, regardless of how large $|\mathcal{F}|$ is.*
On a very high level, our proof proceeds as follows. We consider 0-1 rewards and the following family of problem instances, with parameter $\epsilon>0$ to be adjusted in the analysis:
$$
\displaystyle\mathcal{I}_{j}=\begin{cases}\mu_{i}=\nicefrac{{1}}{{2}}+\nicefrac{{\epsilon}}{{2}}&\text{ for arm }i=j\\
\mu_{i}=\nicefrac{{1}}{{2}}&\text{ for each arm }i\neq j.\end{cases} \tag{17}
$$
for each $j=1,2\,,\ ...\ ,K$ , where $K$ is the number of arms. Recall from the previous chapter that sampling each arm $\tilde{O}(1/\epsilon^{2})$ times suffices for our upper bounds on regret. Indeed, Eq. (7) in Chapter 1 asserts that Successive Elimination would sample each suboptimal arm at most $\tilde{O}(1/\epsilon^{2})$ times, and the remainder of the analysis applies to any algorithm which satisfies (7). We will prove that sampling each arm $\Omega(1/\epsilon^{2})$ times is necessary to determine whether this arm is good or bad. This leads to regret $\Omega(K/\epsilon)$ . We complete the proof by plugging in $\epsilon=\Theta(\sqrt{K/T})$ .
However, the technical details are quite subtle. We present them in several relatively gentle steps.
7 Background on KL-divergence
The proof relies on KL-divergence, an important tool from information theory. We provide a brief introduction to KL-divergence for finite sample spaces, which suffices for our purposes. This material is usually covered in introductory courses on information theory.
Throughout, consider a finite sample space $\Omega$ , and let $p,q$ be two probability distributions on $\Omega$ . Then, the Kullback-Leibler divergence or KL-divergence is defined as:
| | $\displaystyle\mathtt{KL}(p,q)=\sum_{xâ\Omega}p(x)\ln\frac{p(x)}{q(x)}=\mathbb{E}_{p}\left[\ln\frac{p(x)}{q(x)}\right].$ | |
| --- | --- | --- |
This is a notion of distance between two distributions, with the properties that it is non-negative, 0 iff $p=q$ , and small if the distributions $p$ and $q$ are close to one another. However, KL-divergence is not symmetric and does not satisfy the triangle inequality.
**Remark 2.3**
*KL-divergence is a mathematical construct with amazingly useful properties, see Theorem 2.4. The precise definition is not essential to us: any other construct with the same properties would work just as well. The deep reasons as to why KL-divergence should be defined in this way are beyond our scope. That said, hereâs see some intuition behind this definition. Suppose data points $x_{1}\,,\ ...\ ,x_{n}â\Omega$ are drawn independently from some fixed, but unknown distribution $p^{*}$ . Further, suppose we know that this distribution is either $p$ or $q$ , and we wish to use the data to estimate which one is more likely. One standard way to quantify whether distribution $p$ is more likely than $q$ is the log-likelihood ratio,
$$
\Lambda_{n}:=\sum_{i=1}^{n}\ln\frac{p(x_{i})}{q(x_{i})}.
$$
KL-divergence is the expectation of this quantity when $p^{*}=p$ , and also the limit as $nââ$ :
$$
\lim_{n\to\infty}\Lambda_{n}=\operatornamewithlimits{\mathbb{E}}[\Lambda_{n}]=\mathtt{KL}(p,q)\quad\text{if $p^{*}=p$}.
$$*
We present fundamental properties of KL-divergence which we use in this chapter. Throughout, let $\mathtt{RC}_{\epsilon}$ , $\epsilonâ„ 0$ , denote a biased random coin with bias $\nicefrac{{\epsilon}}{{2}}$ , i.e., a distribution over $\{0,1\}$ with expectation $(1+\epsilon)/2$ .
**Theorem 2.4**
*KL-divergence satisfies the following properties:
- Gibbsâ Inequality: $\mathtt{KL}(p,q)â„ 0$ for any two distributions $p,q$ , with equality if and only if $p=q$ .
- Chain rule for product distributions: Let the sample space be a product $\Omega=\Omega_{1}Ă\Omega_{1}Ă...Ă\Omega_{n}$ . Let $p$ and $q$ be two distributions on $\Omega$ such that $p=p_{1}Ă p_{2}Ă...Ă p_{n}$ and $q=q_{1}Ă q_{2}Ă...Ă q_{n}$ , where $p_{j},q_{j}$ are distributions on $\Omega_{j}$ , for each $jâ[n]$ . Then $\mathtt{KL}(p,q)=\sum_{j=1}^{n}\mathtt{KL}(p_{j},q_{j})$ .
- Pinskerâs inequality: for any event $Aâ\Omega$ we have $2\left(p(A)-q(A)\right)^{2}â€\mathtt{KL}(p,q)$ .
- Random coins: $\mathtt{KL}(\mathtt{RC}_{\epsilon},\mathtt{RC}_{0})†2\epsilon^{2}$ , and $\mathtt{KL}(\mathtt{RC}_{0},\mathtt{RC}_{\epsilon})â€\epsilon^{2}$ for all $\epsilonâ(0,\tfrac{1}{2})$ .*
The proofs of these properties are fairly simple (and teachable). We include them in Appendix 13 for completeness, and so as to âdemystifyâ the KL technique.
A typical usage is as follows. Consider the setting from part (b) with $n$ samples from two random coins: $p_{j}=\mathtt{RC}_{\epsilon}$ is a biased random coin, and $q_{j}=\mathtt{RC}_{0}$ is a fair random coin, for each $jâ[n]$ . Suppose we are interested in some event $Aâ\Omega$ , and we wish to prove that $p(A)$ is not too far from $q(A)$ when $\epsilon$ is small enough. Then:
| | $\displaystyle 2(p(A)-q(A))^{2}$ | $\displaystyleâ€\mathtt{KL}(p,q)$ | (by Pinskerâs inequality) | |
| --- | --- | --- | --- | --- |
It follows that $|p(A)-q(A)|â€\epsilon\,\sqrt{n}$ . In particular, $|p(A)-q(A)|<\tfrac{1}{2}$ whenever $\epsilon<\tfrac{1}{2\sqrt{n}}$ . Thus:
**Lemma 2.5**
*Consider sample space $\Omega=\{0,1\}^{n}$ and two distributions on $\Omega$ , $p=\mathtt{RC}_{\epsilon}^{n}$ and $q=\mathtt{RC}_{0}^{n}$ , for some $\epsilon>0$ . Then $|p(A)-q(A)|â€\epsilon\,\sqrt{n}$ for any event $Aâ\Omega$ .*
**Remark 2.6**
*The asymmetry in the definition of KL-divergence does not matter in the argument above: we could have written $\mathtt{KL}(q,p)$ instead of $\mathtt{KL}(p,q)$ . Likewise, it does not matter throughout this chapter.*
8 A simple example: flipping one coin
We start with a simple application of the KL-divergence technique, which is also interesting as a standalone result. Consider a biased random coin: a distribution on $\{0,1\}$ ) with an unknown mean $\muâ[0,1]$ . Assume that $\muâ\{\mu_{1},\mu_{2}\}$ for two known values $\mu_{1}>\mu_{2}$ . The coin is flipped $T$ times. The goal is to identify if $\mu=\mu_{1}$ or $\mu=\mu_{2}$ with low probability of error.
Let us make our goal a little more precise. Define $\Omega:=\{0,1\}^{T}$ to be the sample space for the outcomes of $T$ coin tosses. Let us say that we need a decision rule
$$
\mathtt{Rule}:\Omega\rightarrow\{\mathtt{High},\mathtt{Low}\}
$$
which satisfies the following two properties:
$$
\displaystyle\Pr\left[\,\mathtt{Rule}(\text{observations})=\mathtt{High}\mid\mu=\mu_{1}\,\right] \displaystyle\geq 0.99, \displaystyle\Pr\left[\,\mathtt{Rule}(\text{observations})=\mathtt{Low}~~\mid\mu=\mu_{2}\,\right] \displaystyle\geq 0.99. \tag{18}
$$
How large should $T$ be for for such a decision rule to exist? We know that $T\sim(\mu_{1}-\mu_{2})^{-2}$ is sufficient. What we prove is that it is also necessary. We focus on the special case when both $\mu_{1}$ and $\mu_{2}$ are close to $\frac{1}{2}$ .
**Lemma 2.7**
*Let $\mu_{1}=\frac{1+\epsilon}{2}$ and $\mu_{2}=\frac{1}{2}$ . Fix a decision rule which satisfies (18) and (19). Then $T>\tfrac{1}{4\,\epsilon^{2}}$ .*
* Proof*
Let $A_{0}â\Omega$ be the event this rule returns $\mathtt{High}$ . Then
$$
\displaystyle\Pr[A_{0}\mid\mu=\mu_{1}]-\Pr[A_{0}\mid\mu=\mu_{2}]\geq 0.98. \tag{20}
$$ Let $P_{i}(A)=\Pr[A\mid\mu=\mu_{i}]$ , for each event $Aâ\Omega$ and each $iâ\{1,2\}$ . Then $P_{i}=P_{i,1}Ă...Ă P_{i,T}$ , where $P_{i,t}$ is the distribution of the $t^{th}$ coin toss if $\mu=\mu_{i}$ . Thus, the basic KL-divergence argument summarized in Lemma 2.5 applies to distributions $P_{1}$ and $P_{2}$ . It follows that $|P_{1}(A)-P_{2}(A)|â€\epsilon\,\sqrt{T}$ . Plugging in $A=A_{0}$ and $Tâ€\tfrac{1}{4\epsilon^{2}}$ , we obtain $|P_{1}(A_{0})-P_{2}(A_{0})|<\tfrac{1}{2}$ , contradicting (20). â
Remarkably, the proof applies to all decision rules at once!
9 Flipping several coins: âbest-arm identificationâ
Let us extend the previous example to multiple coins. We consider a bandit problem with $K$ arms, where each arm is a biased random coin with unknown mean. More formally, the reward of each arm is drawn independently from a fixed but unknown Bernoulli distribution. After $T$ rounds, the algorithm outputs an arm $y_{T}$ : a prediction for which arm is optimal (has the highest mean reward). We call this version âbest-arm identificationâ. We are only be concerned with the quality of prediction, rather than regret.
As a matter of notation, the set of arms is $[K]$ , $\mu(a)$ is the mean reward of arm $a$ , and a problem instance is specified as a tuple $\mathcal{I}=(\mu(a):aâ[K])$ .
For concreteness, let us say that a good algorithm for âbest-arm identificationâ should satisfy
$$
\Pr\left[\,\text{prediction $y_{T}$ is correct }\mid\mathcal{I}\,\right]\geq 0.99 \tag{21}
$$
for each problem instance $\mathcal{I}$ . We will use the family (17) of problem instances, with parameter $\epsilon>0$ , to argue that one needs $Tâ„\Omega\left(\frac{K}{\epsilon^{2}}\right)$ for any algorithm to âworkâ, i.e., satisfy property (21), on all instances in this family. This result is of independent interest, regardless of the regret bound that weâve set out to prove.
In fact, we prove a stronger statement which will also be the crux in the proof of the regret bound.
**Lemma 2.8**
*Consider a âbest-arm identificationâ problem with $Tâ€\frac{cK}{\epsilon^{2}}$ , for a small enough absolute constant $c>0$ . Fix any deterministic algorithm for this problem. Then there exists at least ${\lceil{K/3}\rceil}$ arms $a$ such that, for problem instances $\mathcal{I}_{a}$ defined in (17), we have
$$
\displaystyle\Pr\left[\,y_{T}=a\mid\mathcal{I}_{a}\,\right]<\nicefrac{{3}}{{4}}. \tag{22}
$$*
The proof for $K=2$ arms is simpler, so we present it first. The general case is deferred to Section 10.
* Proof (K=2K=2arms)*
Let us set up the sample space which we will use in the proof. Let
$$
\left(\,r_{t}(a):\;a\in[K],t\in[T]\,\right)
$$
be a tuple of mutually independent Bernoulli random variables such that $\operatornamewithlimits{\mathbb{E}}\left[\,r_{t}(a)\,\right]=\mu(a)$ . We refer to this tuple as the rewards table, where we interpret $r_{t}(a)$ as the reward received by the algorithm for the $t$ -th time it chooses arm $a$ . The sample space is $\Omega=\{0,1\}^{KĂ T}$ , where each outcome $\omegaâ\Omega$ corresponds to a particular realization of the rewards table. Any event about the algorithm can be interpreted as a subset of $\Omega$ , i.e., the set of outcomes $\omegaâ\Omega$ for which this event happens; we assume this interpretation throughout without further notice. Each problem instance $\mathcal{I}_{j}$ defines distribution $P_{j}$ on $\Omega$ :
$$
P_{j}(A)=\Pr\left[\,A\mid\text{instance $\mathcal{I}_{j}$}\,\right]\quad\text{for each $A\subset\Omega$}.
$$
Let $P_{j}^{a,t}$ be the distribution of $r_{t}(a)$ under instance $\mathcal{I}_{j}$ , so that $P_{j}=\prod_{aâ[K],\;tâ[T]}P_{j}^{a,t}$ . We need to prove that (22) holds for at least one of the arms. For the sake of contradiction, assume it fails for both arms. Let $A=\{y_{T}=1\}â\Omega$ be the event that the algorithm predicts arm $1$ . Then $P_{1}(A)â„\nicefrac{{3}}{{4}}$ and $P_{2}(A)â€\nicefrac{{1}}{{4}}$ , so their difference is $P_{1}(A)-P_{2}(A)â„\nicefrac{{1}}{{2}}$ . To arrive at a contradiction, we use a similar KL-divergence argument as before:
$$
\displaystyle 2\left(\,P_{1}(A)-P_{2}(A)\,\right)^{2} \displaystyle\leq\mathtt{KL}(P_{1},P_{2}) \displaystyle=\sum_{a=1}^{K}\sum_{t=1}^{T}\mathtt{KL}(P_{1}^{a,t},P_{2}^{a,t}) \displaystyle\leq 2T\cdot 2\epsilon^{2} \displaystyle\text{\emph{(by Theorem~\ref{LB:thm:KL-props}(d))}}. \tag{23}
$$
The last inequality holds because for each arm $a$ and each round $t$ , one of the distributions $P_{1}^{a,t}$ and $P_{2}^{a,t}$ is a fair coin $\mathtt{RC}_{0}$ , and another is a biased coin $\mathtt{RC}_{\epsilon}$ . Simplifying (23),
$$
P_{1}(A)-P_{2}(A)\leq\epsilon\sqrt{2\,T}<\tfrac{1}{2}\quad\text{whenever $T\leq(\tfrac{1}{4\epsilon})^{2}$}.\qed
$$
**Corollary 2.9**
*Assume $T$ is as in Lemma 2.8. Fix any algorithm for âbest-arm identificationâ. Choose an arm $a$ uniformly at random, and run the algorithm on instance $\mathcal{I}_{a}$ . Then $\Pr[y_{T}â a]â„\tfrac{1}{12}$ , where the probability is over the choice of arm $a$ and the randomness in rewards and the algorithm.*
* Proof*
Lemma 2.8 immediately implies this corollary for deterministic algorithms. The general case follows because any randomized algorithm can be expressed as a distribution over deterministic algorithms. â
Finally, we use Corollary 2.9 to finish our proof of the $\sqrt{KT}$ lower bound on regret.
**Theorem 2.10**
*Fix time horizon $T$ and the number of arms $K$ . Fix a bandit algorithm. Choose an arm $a$ uniformly at random, and run the algorithm on problem instance $\mathcal{I}_{a}$ . Then
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}[R(T)]\geq\Omega(\sqrt{KT}), \tag{24}
$$
where the expectation is over the choice of arm $a$ and the randomness in rewards and the algorithm.*
* Proof*
Fix the parameter $\epsilon>0$ in (17), to be adjusted later, and assume that $Tâ€\frac{cK}{\epsilon^{2}}$ , where $c$ is the constant from Lemma 2.8. Fix round $t$ . Let us interpret the algorithm as a âbest-arm identificationâ algorithm, where the prediction is simply $a_{t}$ , the arm chosen in this round. We can apply Corollary 2.9, treating $t$ as the time horizon, to deduce that $\Pr[a_{t}â a]â„\tfrac{1}{12}$ . In words, the algorithm chooses a non-optimal arm with probability at least $\tfrac{1}{12}$ . Recall that for each problem instances $\mathcal{I}_{a}$ , the âgapâ $\Delta(a_{t}):=\mu^{*}-\mu(a_{t})$ is $\epsilon/2$ whenever a non-optimal arm is chosen. Therefore,
$$
\operatornamewithlimits{\mathbb{E}}[\Delta(a_{t})]=\Pr[a_{t}\neq a]\cdot\tfrac{\epsilon}{2}\geq\epsilon/24.
$$
Summing up over all rounds, $\operatornamewithlimits{\mathbb{E}}[R(T)]=\sum_{t=1}^{T}\operatornamewithlimits{\mathbb{E}}[\Delta(a_{t})]â„\epsilon T/24$ . We obtain (24) with $\epsilon=\sqrt{cK/T}$ . â
10 Proof of Lemma 2.8 for the general case
Reusing the proof for $K=2$ arms only works for time horizon $T†c/\epsilon^{2}$ , which yields the lower bound of $\Omega(\sqrt{T})$ . Increasing $T$ by the factor of $K$ requires a more delicate version of the KL-divergence argument, which improves the right-hand side of (23) to $O(T\epsilon^{2}/K)$ .
For the sake of the analysis, we will consider an additional problem instance
$$
\mathcal{I}_{0}=\{\mu_{i}=\tfrac{1}{2}\text{ for all arms $i$ }\},
$$
which we call the âbase instanceâ. Let $\operatornamewithlimits{\mathbb{E}}_{0}[·]$ be the expectation given this problem instance. Also, let $T_{a}$ be the total number of times arm $a$ is played.
We consider the algorithmâs performance on problem instance $\mathcal{I}_{0}$ , and focus on arms $j$ that are âneglectedâ by the algorithm, in the sense that the algorithm does not choose arm $j$ very often and is not likely to pick $j$ for the guess $y_{T}$ . Formally, we observe the following:
$$
\displaystyle{\textstyle\operatornamewithlimits{\mathbb{E}}_{0}}(T_{j})\leq\tfrac{3T}{K}, \displaystyle P_{0}(y_{T}=j)\leq\tfrac{3}{K}. \tag{25}
$$
(To prove (25), assume for contradiction that we have more than $\frac{K}{3}$ arms with $\operatornamewithlimits{\mathbb{E}}_{0}(T_{j})>\frac{3T}{K}$ . Then the expected total number of times these arms are played is strictly greater than $T$ , which is a contradiction. (26) is proved similarly.) By Markov inequality,
$$
\textstyle{\operatornamewithlimits{\mathbb{E}}_{0}}(T_{j})\leq\frac{3T}{K}\text{ implies that }\Pr[T_{j}\leq\frac{24T}{K}]\geq\nicefrac{{7}}{{8}}.
$$
Since the sets of arms in (25) and (26) must overlap on least $\frac{K}{3}$ arms, we conclude:
$$
\text{There are at least $\nicefrac{{K}}{{3}}$ arms $j$ such that }\Pr\left[\,T_{j}\leq\tfrac{24T}{K}\,\right]\geq\nicefrac{{7}}{{8}}\text{ and }P_{0}(y_{T}=j)\leq\nicefrac{{3}}{{K}}. \tag{27}
$$
We will now refine our definition of the sample space. For each arm $a$ , define the $t$ -round sample space $\Omega_{a}^{t}=\{0,1\}^{t}$ , where each outcome corresponds to a particular realization of the tuple $(r_{s}(a):\;sâ[t])$ . (Recall that we interpret $r_{t}(a)$ as the reward received by the algorithm for the $t$ -th time it chooses arm $a$ .) Then the âfullâ sample space we considered before can be expressed as $\Omega=\prod_{aâ[K]}\Omega_{a}^{T}$ .
Fix an arm $j$ satisfying the two properties in (27). We will prove that
$$
\displaystyle P_{j}\left[\,Y_{T}=j\,\right]\leq\nicefrac{{1}}{{2}}. \tag{28}
$$
Since there are at least $K/3$ such arms, this suffices to imply the Lemma.
We consider a âreducedâ sample space in which arm $j$ is played only $m=\min\left(\,T,\,24T/K\,\right)$ times:
$$
\displaystyle\Omega^{*}=\Omega_{j}^{m}\times\prod_{\text{arms $a\neq j$}}\Omega_{a}^{T}. \tag{29}
$$
For each problem instance $\mathcal{I}_{\ell}$ , we define distribution $P^{*}_{\ell}$ on $\Omega^{*}$ as follows:
$$
P^{*}_{\ell}(A)=\Pr[A\mid\mathcal{I}_{\ell}]\quad\text{for each $A\subset\Omega^{*}$}.
$$
In other words, distribution $P^{*}_{\ell}$ is a restriction of $P_{\ell}$ to the reduced sample space $\Omega^{*}$ .
We apply the KL-divergence argument to distributions $P^{*}_{0}$ and $P^{*}_{j}$ . For each event $Aâ\Omega^{*}$ :
| | $\displaystyle 2\left(\,P_{0}^{*}(A)-P_{j}^{*}(A)\,\right)^{2}$ | $\displaystyleâ€\mathtt{KL}(P_{0}^{*},P_{j}^{*})$ | (by Pinskerâs inequality) | |
| --- | --- | --- | --- | --- |
The last inequality holds because each arm $aâ j$ has identical reward distributions under problem instances $\mathcal{I}_{0}$ and $\mathcal{I}_{j}$ (namely the fair coin $\mathtt{RC}_{0}$ ), and for arm $j$ we only need to sum up over $m$ samples rather than $T$ .
Therefore, assuming $Tâ€\frac{cK}{\epsilon^{2}}$ with small enough constant $c$ , we can conclude that
$$
\displaystyle|P_{0}^{*}(A)-P_{j}^{*}(A)|\leq\epsilon\sqrt{m}<\tfrac{1}{8}\quad\text{for all events $A\subset\Omega^{*}$}. \tag{30}
$$
To apply (30), we need to make sure that $Aâ\Omega^{*}$ , i.e., that whether this event holds is completely determined by the first $m$ samples of arm $j$ (and all samples of other arms). In particular, we cannot take $A=\{y_{T}=j\}$ , the event that we are interested in, because this event may depend on more than $m$ samples of arm $j$ . Instead, we apply (30) twice: to events
$$
\displaystyle A=\{y_{T}=j\text{ and }T_{j}\leq m\}\text{ and }A^{\prime}=\{T_{j}>m\}. \tag{31}
$$
Recall that we interpret these events as subsets of the sample space $\Omega=\{0,1\}^{KĂ T}$ , i.e., as a subset of possible realizations of the rewards table. Note that $A,A^{\prime}â\Omega^{*}$ ; indeed, $A^{\prime}â\Omega^{*}$ because whether the algorithm samples arm $j$ more than $m$ times is completely determined by the first $m$ samples of this arm (and all samples of the other arms). We are ready for the final computation:
$$
\displaystyle P_{j}(A) \displaystyle\leq\tfrac{1}{8}+P_{0}(A) \displaystyle\leq\tfrac{1}{8}+P_{0}(y_{T}=j) \displaystyle\leq\tfrac{1}{4} \displaystyle\text{\emph{(by our choice of arm $j$)}}. \displaystyle P_{j}(A^{\prime}) \displaystyle\leq\tfrac{1}{8}+P_{0}(A^{\prime}) \displaystyle\leq\tfrac{1}{4} \displaystyle\text{\emph{(by our choice of arm $j$)}}. \displaystyle P_{j}(Y_{T}=j) \displaystyle\leq P_{j}^{*}(Y_{T}=j~and~T_{j}\leq m)+P_{j}^{*}(T_{j}>m) \displaystyle=P_{j}(A)+P_{j}(A^{\prime})\leq\nicefrac{{1}}{{2}}. \tag{30}
$$
This completes the proof of Eq. (28), and hence that of the Lemma.
11 Lower bounds for non-adaptive exploration
The same information-theoretic technique implies much stronger lower bounds for non-adaptive exploration, as per Definition 1.7. First, the $T^{2/3}$ upper bounds from Section 2 are essentially the best possible.
**Theorem 2.11**
*Consider any algorithm which satisfies non-adaptive exploration. Fix time horizon $T$ and the number of arms $K<T$ . Then there exists a problem instance such that $\operatornamewithlimits{\mathbb{E}}[R(T)]â„\Omega\left(\,T^{2/3}· K^{1/3}\,\right)$ .*
Second, we rule out logarithmic upper bounds such as (11). The statement is more nuanced, requiring the algorithm to be at least somewhat reasonable in the worst case. The worst-case assumption is necessary. For example, if we only focus on problem instances with minimum gap at least $\Delta$ , then Explore-first with $N=O(\Delta^{-2}\log T)$ rounds of exploration yields logarithmic regret.
**Theorem 2.12**
*In the setup of Theorem 2.11, suppose $\operatornamewithlimits{\mathbb{E}}[R(T)]†C· T^{\gamma}$ for all problem instances, for some numbers $\gammaâ[\nicefrac{{2}}{{3}},1)$ and $C>0$ . Then for any problem instance a random permutation of arms yields
$$
\operatornamewithlimits{\mathbb{E}}\left[\,R(T)\,\right]\textstyle\geq\Omega\left(\,C^{-2}\cdot T^{\lambda}\cdot\sum_{a}\Delta(a)\,\right),\quad\text{where $\lambda=2(1-\gamma)$.}
$$*
In particular, if an algorithm achieves regret $\operatornamewithlimits{\mathbb{E}}[R(T)]â€\tilde{O}\left(\,T^{2/3}· K^{1/3}\,\right)$ over all problem instances, like Explore-first and Epsilon-greedy, this algorithm incurs a similar regret for every problem instance, if the arms therein are randomly permuted: $\operatornamewithlimits{\mathbb{E}}[R(T)]â„\tilde{\Omega}\left(\,\Delta· T^{2/3}· K^{1/3}\,\right)$ , where $\Delta$ is the minimal gap. This follows by taking $C=\tilde{O}(K^{1/3})$ in the theorem.
The KL-divergence technique is âimportedâ via Corollary 2.9. Theorem 2.12 is fairly straightforward given this corollary, and Theorem 2.11 follows by taking $C=K^{1/3}$ ; see Exercise 2.1 and hints therein.
12 Instance-dependent lower bounds (without proofs)
The other fundamental lower bound asserts $\Omega(\log T)$ regret with an instance-dependent constant and, unlike the $\sqrt{KT}$ lower bound, applies to every problem instance. This lower bound complements the $\log(T)$ upper bound that we proved for algorithms UCB1 and Successive Elimination. We formulate and explain this lower bound below, without presenting a proof. The formulation is quite subtle, so we present it in stages.
Let us focus on 0-1 rewards. For a particular problem instance, we are interested in how $\operatornamewithlimits{\mathbb{E}}[R(t)]$ grows with $t$ . We start with a simpler and weaker version:
**Theorem 2.13**
*No algorithm can achieve regret $\operatornamewithlimits{\mathbb{E}}[R(t)]=o(c_{\mathcal{I}}\;\log t)$ for all problem instances $\mathcal{I}$ , where the âconstantâ $c_{\mathcal{I}}$ can depend on the problem instance but not on the time $t$ .*
This version guarantees at least one problem instance on which a given algorithm has âhighâ regret. We would like to have a stronger lower bound which guarantees âhighâ regret for each problem instance. However, such lower bound is impossible because of a trivial counterexample: an algorithm which always plays arm $1$ , as dumb as it is, nevertheless has $0$ regret on any problem instance for which arm $1$ is optimal. To rule out such counterexamples, we require the algorithm to perform reasonably well (but not necessarily optimally) across all problem instances.
**Theorem 2.14**
*Fix $K$ , the number of arms. Consider an algorithm such that
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}[R(t)]\leq O(C_{\mathcal{I},\alpha}\;t^{\alpha})\quad\text{for each problem instance $\mathcal{I}$ and each $\alpha>0$}. \tag{32}
$$
Here the âconstantâ $C_{\mathcal{I},\alpha}$ can depend on the problem instance $\mathcal{I}$ and the $\alpha$ , but not on time $t$ . Fix an arbitrary problem instance $\mathcal{I}$ . For this problem instance:
$$
\displaystyle\text{There exists time $t_{0}$ such that for any $t\geq t_{0}$}\quad\operatornamewithlimits{\mathbb{E}}[R(t)]\geq C_{\mathcal{I}}\ln(t), \tag{33}
$$
for some constant $C_{\mathcal{I}}$ that depends on the problem instance, but not on time $t$ .*
**Remark 2.15**
*For example, Assumption (32) is satisfied for any algorithm with $\operatornamewithlimits{\mathbb{E}}[R(t)]â€(\log t)^{1000}$ .*
Let us refine Theorem 2.14 and specify how the instance-dependent constant $C_{\mathcal{I}}$ in (33) can be chosen. In what follows, $\Delta(a)=\mu^{*}-\mu(a)$ be the âgapâ of arm $a$ .
**Theorem 2.16**
*For each problem instance $\mathcal{I}$ and any algorithm that satisfies (32),
- the bound (33) holds with
$$
C_{\mathcal{I}}=\sum_{a:\;\Delta(a)>0}\;\frac{\mu^{*}(1-\mu^{*})}{\Delta(a)}.
$$
- for each $\epsilon>0$ , the bound (33) holds with $C_{\mathcal{I}}=C^{0}_{\mathcal{I}}-\epsilon$ , where
$$
C^{0}_{\mathcal{I}}=\sum_{a:\;\Delta(a)>0}\;\frac{\Delta(a)}{\mathtt{KL}(\mu(a),\,\mu^{*})}-\epsilon.
$$*
**Remark 2.17**
*The lower bound from part (a) is similar to the upper bound achieved by UCB1 and Successive Elimination: $R(T)â€\sum_{a:\;\Delta(a)>0}\;\frac{O(\log T)}{\Delta(a)}$ . In particular, we see that the upper bound is optimal up to a constant factor when $\mu^{*}$ is bounded away from 0 and $1$ , e.g., when $\mu^{*}â\left[\,\nicefrac{{1}}{{4}},\nicefrac{{3}}{{4}}\,\right]$ .*
**Remark 2.18**
*Part (b) is a stronger (i.e., larger) lower bound which implies the more familiar form in (a). Several algorithms in the literature are known to come arbitrarily close to this lower bound. In particular, a version of Thompson Sampling (another standard algorithm discussed in Chapter 3) achieves regret
$$
R(t)\leq(1+\delta)\,C^{0}_{\mathcal{I}}\;\ln(t)+C^{\prime}_{\mathcal{I}}/\delta^{2},\quad\forall\delta>0,
$$
where $C^{0}_{\mathcal{I}}$ is from part (b) and $C^{\prime}_{\mathcal{I}}$ is some other instance-dependent constant.*
13 Literature review and discussion
The $\Omega(\sqrt{KT})$ lower bound on regret is from Auer et al. (2002b). KL-divergence and its properties is âtextbook materialâ from information theory, e.g., see Cover and Thomas (1991). The outline and much of the technical details in the present exposition are based on the lecture notes from Kleinberg (2007). That said, we present a substantially simpler proof, in which we replace the general âchain ruleâ for KL-divergence with the special case of independent distributions (Theorem 2.4 (b) in Section 7). This special case is much easier to formulate and apply, especially for those not deeply familiar with information theory. The proof of Lemma 2.8 for general $K$ is modified accordingly. In particular, we define the âreducedâ sample space $\Omega^{*}$ with only a small number of samples from the âbadâ arm $j$ , and apply the KL-divergence argument to carefully defined events in (31), rather than a seemingly more natural event $A=\{y_{T}=j\}$ .
Lower bounds for non-adaptive exploration have been folklore in the community. The first published version traces back to Babaioff et al. (2014), to the best of our knowledge. They define a version of non-adaptive exploration and derive similar lower bounds as ours, but for a slightly different technical setting.
The logarithmic lower bound from Section 12 is due to Lai and Robbins (1985). Its proof is also based on the KL-divergence technique. Apart from the original paper, it can can also be found in (Bubeck and Cesa-Bianchi, 2012). Our exposition is more explicit on âunwrappingâ what this lower bound means.
While these two lower bounds essentially resolve the basic version of multi-armed bandits, they do not suffice for many other versions. Indeed, some bandit problems posit auxiliary constraints on the problem instances, such as Lipschitzness or linearity (see Section 4), and the lower-bounding constructions need to respect these constraints. Typically such lower bounds do not depend on the number of actions (which may be very large or even infinite). In some other bandit problems the constraints are on the algorithm, e.g., a limited inventory. Then much stronger lower bounds may be possible.
Therefore, a number of problem-specific lower bounds have been proved over the years. A representative, but likely incomplete, list is below:
- for dynamic pricing (Kleinberg and Leighton, 2003; Babaioff et al., 2015a) and Lipschitz bandits (Kleinberg, 2004; Slivkins, 2014; Kleinberg et al., 2019; Krishnamurthy et al., 2020); see Chapter 4 for definitions and algorithms, and Section 20.2 for a (simple) lower bound and its proof.
- for linear bandits (e.g., Dani et al., 2007, 2008; Rusmevichientong and Tsitsiklis, 2010; Shamir, 2015) and combinatorial (semi-)bandits (e.g., Audibert et al., 2014; Kveton et al., 2015c); see Chapter 7 for definitions and algorithms.
- for pay-per-click ad auctions (Babaioff et al., 2014; Devanur and Kakade, 2009). Ad auctions are parameterized by click probabilities of ads, which are a priori unknown but can be learned over time by a bandit algorithm. The said algorithm is constrained to be compatible with advertisersâ incentives.
- for dynamic pricing with limited supply (Besbes and Zeevi, 2009; Babaioff et al., 2015a) and bandits with resource constraints (Badanidiyuru et al., 2018; Immorlica et al., 2022; Sankararaman and Slivkins, 2021); see Chapter 10 for definitions and algorithms.
- for best-arm identification (e.g., Kaufmann et al., 2016; Carpentier and Locatelli, 2016).
Some lower bounds in the literature are derived from first principles, like in this chapter, e.g., the lower bounds in Kleinberg and Leighton (2003); Kleinberg (2004); Babaioff et al. (2014); Badanidiyuru et al. (2018). Some other lower bounds are derived by reduction to more basic ones (e.g., the lower bounds in Babaioff et al., 2015a; Kleinberg et al., 2019, and the one in Section 20.2). The latter approach focuses on constructing the problem instances and side-steps the lengthy KL-divergence arguments.
14 Exercises and hints
**Exercise 2.1 (non-adaptive exploration)**
*Prove Theorems 2.11 and 2.12. Specifically, consider an algorithm which satisfies non-adaptive exploration. Let $N$ be the number of exploration rounds. Then:
- there is a problem instance such that $\operatornamewithlimits{\mathbb{E}}[R(T)]â„\Omega(\;T·\sqrt{K/\operatornamewithlimits{\mathbb{E}}[N]}\;)$ .
- for each problem instance, randomly permuting the arms yields $\operatornamewithlimits{\mathbb{E}}[R(T)]â„\operatornamewithlimits{\mathbb{E}}[N]·\tfrac{1}{K}\sum_{a}\Delta(a)$ .
- use parts (a,b) to derive Theorems 2.11 and 2.12. Hint: For part (a), start with a deterministic algorithm. Consider each round separately and invoke Corollary 2.9. For a randomized algorithm, focus on event $\{N†2\,\operatornamewithlimits{\mathbb{E}}[N]\}$ ; its probability is at least $\nicefrac{{1}}{{2}}$ by Markov inequality. Part (b) can be proved from first principles. To derive Theorem 2.12, use part (b) to lower-bound $\operatornamewithlimits{\mathbb{E}}[N]$ , then apply part (a). Set $C=K^{1/3}$ in Theorem 2.12 to derive Theorems 2.11.*
Chapter 3 Bayesian Bandits and Thompson Sampling
We introduce a Bayesian version of stochastic bandits, and discuss Thompson Sampling, an important algorithm for this version, known to perform well both in theory and in practice. The exposition is self-contained, introducing concepts from Bayesian statistics as needed.
Prerequisites: Chapter 1.
The Bayesian bandit problem adds the Bayesian assumption to stochastic bandits: the problem instance $\mathcal{I}$ is drawn initially from some known distribution $\mathbb{P}$ . The time horizon $T$ and the number of arms $K$ are fixed. Then an instance of stochastic bandits is specified by the mean reward vector $\muâ[0,1]^{K}$ and the reward distributions $(\mathcal{D}_{a}:\,aâ[K])$ . The distribution $\mathbb{P}$ is called the prior distribution, or the Bayesian prior. The goal is to optimize Bayesian regret: expected regret for a particular problem instance $\mathcal{I}$ , as defined in (1), in expectation over the problem instances:
$$
\displaystyle\mathtt{BR}(T):=\operatornamewithlimits{\mathbb{E}}_{\mathcal{I}\sim\mathbb{P}}\left[\,\operatornamewithlimits{\mathbb{E}}\left[\,R(T)\mid\mathcal{I}\,\right]\,\right]=\textstyle\operatornamewithlimits{\mathbb{E}}_{\mathcal{I}\sim\mathbb{P}}\left[\,\mu^{*}\cdot T-\sum_{t\in[T]}\mu(a_{t})\,\right]. \tag{34}
$$
Bayesian bandits follow a well-known approach from Bayesian statistics: posit that the unknown quantity is sampled from a known distribution, and optimize in expectation over this distribution. Note that a âworst-caseâ regret bound (an upper bound on $\operatornamewithlimits{\mathbb{E}}[R(T)]$ which holds for all problem instances) implies the same upper bound on Bayesian regret.
Simplifications. We make several assumptions to simplify presentation. First, the realized rewards come from a single-parameter family of distributions. There is a family of real-valued distributions $(\mathcal{D}_{\nu}$ , $\nuâ[0,1])$ , fixed and known to the algorithm, such that each distribution $\mathcal{D}_{\nu}$ has expectation $\nu$ . Typical examples are Bernoulli rewards and unit-variance Gaussians. The reward of each arm $a$ is drawn from distribution $\mathcal{D}_{\mu(a)}$ , where $\mu(a)â[0,1]$ is the mean reward. We will keep the single-parameter family fixed and implicit in our notation. Then the problem instance is completely specified by the mean reward vector $\muâ[0,1]^{K}$ , and the prior $\mathbb{P}$ is simply a distribution over $[0,1]^{K}$ that $\mu$ is drawn from.
Second, unless specified otherwise, the realized rewards can only take finitely many different values, and the prior $\mathbb{P}$ has a finite support, denoted $\mathcal{F}$ . Then we can focus on concepts and arguments essential to Thompson Sampling, rather than worry about the intricacies of integrals and probability densities. However, the definitions and lemmas stated below carry over to arbitrary priors and arbitrary reward distributions.
Third, the best arm $a^{*}$ is unique for each mean reward vector in the support of $\mathbb{P}$ . This is just for simplicity: this assumption can be easily removed at the cost of slightly more cumbersome notation.
15 Bayesian update in Bayesian bandits
An essential operation in Bayesian statistics is Bayesian update: updating the prior distribution given the new data. Let us discuss how this operation plays out for Bayesian bandits.
15.1 Terminology and notation
Fix round $t$ . Algorithmâs data from the first $t$ rounds is a sequence of action-reward pairs, called $t$ -history:
$$
H_{t}=\left(\,(a_{1},r_{1})\,,\ \ldots\ ,(a_{t},r_{t})\,\right)\in(\mathcal{A}\times\mathbb{R})^{t}.
$$
It is a random variable which depends on the mean reward vector $\mu$ , the algorithm, and the reward distributions (and the randomness in all three). A fixed sequence
$$
\displaystyle H=((a^{\prime}_{1},r^{\prime}_{1})\,,\ \ldots\ ,(a^{\prime}_{t},r^{\prime}_{t}))\in(\mathcal{A}\times\mathbb{R})^{t} \tag{35}
$$
is called a feasible $t$ -history if it satisfies $\Pr[H_{t}=H]>0$ for some bandit algorithm; call such algorithm $H$ -consistent. One such algorithm, called the $H$ -induced algorithm, deterministically chooses arm $a^{\prime}_{s}$ in each round $sâ[t]$ . Let $\mathcal{H}_{t}$ be the set of all feasible $t$ -histories; it is finite, because each reward can only take finitely many values. In particular, $\mathcal{H}_{t}=(\mathcal{A}Ă\{0,1\})^{t}$ for Bernoulli rewards and a prior $\mathbb{P}$ such that $\Pr[\mu(a)â(0,1)]=1$ for all arms $a$ .
In what follows, fix a feasible $t$ -history $H$ . We are interested in the conditional probability
$$
\displaystyle\mathbb{P}_{H}(\mathcal{M}):=\Pr\left[\,\mu\in\mathcal{M}\mid H_{t}=H\,\right],\qquad\forall\mathcal{M}\subset[0,1]^{K}. \tag{36}
$$
This expression is well-defined for the $H$ -induced algorithm, and more generally for any $H$ -consistent bandit algorithm. We interpret $\mathbb{P}_{H}$ as a distribution over $[0,1]^{K}$ .
Reflecting the standard terminology in Bayesian statistics, $\mathbb{P}_{H}$ is called the (Bayesian) posterior distribution after round $t$ . The process of deriving $\mathbb{P}_{H}$ is called Bayesian update of $\mathbb{P}$ given $H$ .
15.2 Posterior does not depend on the algorithm
A fundamental fact about Bayesian bandits is that distribution $\mathbb{P}_{H}$ does not depend on which $H$ -consistent bandit algorithm has collected the history. Thus, w.l.o.g. it is the $H$ -induced algorithm.
**Lemma 3.1**
*Distribution $\mathbb{P}_{H}$ is the same for all $H$ -consistent bandit algorithms.*
The proof takes a careful argument; in particular, it is essential that the algorithmâs action probabilities are determined by the history, and reward distribution is determined by the chosen action.
* Proof*
It suffices to prove the lemma for a singleton set $\mathcal{M}=\{\tilde{\mu}\}$ , for any given vector $\tilde{\mu}â[0,1]^{K}$ . Thus, we are interested in the conditional probability of $\{\mu=\tilde{\mu}\}$ . Recall that the reward distribution with mean reward $\tilde{\mu}(a)$ places probability $\mathcal{D}_{\tilde{\mu}(a)}(r)$ on every given value $râ\mathbb{R}$ . Let us use induction on $t$ . The base case is $t=0$ . To make it well-defined, let us define the $0$ -history as $H_{0}=\emptyset$ , so that $H=\emptyset$ to be the only feasible $0$ -history. Then, all algorithms are $\emptyset$ -consistent, and the conditional probability $\Pr[\mu=\tilde{\mu}\mid H_{0}=H]$ is simply the prior probability $\mathbb{P}(\tilde{\mu})$ . The main argument is the induction step. Consider round $tâ„ 1$ . Write $H$ as concatenation of some feasible $(t-1)$ -history $H^{\prime}$ and an action-reward pair $(a,r)$ . Fix an $H$ -consistent bandit algorithm, and let
$$
\pi(a)=\Pr\left[\,a_{t}=a\mid H_{t-1}=H^{\prime}\,\right]
$$
be the probability that this algorithm assigns to each arm $a$ in round $t$ given the history $H^{\prime}$ . Note that this probability does not depend on the mean reward vector $\mu$ . | | $\displaystyle\frac{\Pr[\mu=\tilde{\mu}\text{ and }H_{t}=H]}{\Pr[H_{t-1}=H^{\prime}]}$ | $\displaystyle=\Pr\left[\,\mu=\tilde{\mu}\text{ and }(a_{t},r_{t})=(a,r)\mid H_{t-1}=H^{\prime}\,\right]$ | |
| --- | --- | --- | --- |
Therefore,
| | $\displaystyle\Pr[H_{t}=H]=\pi(a)·\Pr[H_{t-1}=H^{\prime}]\;\sum_{\tilde{\mu}â\mathcal{F}}\mathbb{P}_{H^{\prime}}(\tilde{\mu})·\mathcal{D}_{\tilde{\mu}(a)}(r).$ | |
| --- | --- | --- |
It follows that
| | $\displaystyle\mathbb{P}_{H}(\tilde{\mu})=\frac{\Pr[\mu=\tilde{\mu}\text{ and }H_{t}=H]}{\Pr[H_{t}=H]}=\frac{\mathbb{P}_{H^{\prime}}(\tilde{\mu})·\mathcal{D}_{\tilde{\mu}(a)}(r)}{\sum_{\tilde{\mu}â\mathcal{F}}\mathbb{P}_{H^{\prime}}(\tilde{\mu})·\mathcal{D}_{\tilde{\mu}(a)}(r)}.$ | |
| --- | --- | --- |
By the induction hypothesis, the posterior distribution $\mathbb{P}_{H^{\prime}}$ does not depend on the algorithm. So, the expression above does not depend on the algorithm, either. â
It follows that $\mathbb{P}_{H}$ stays the same if the rounds are permuted:
**Corollary 3.2**
*$\mathbb{P}_{H}=\mathbb{P}_{H^{\prime}}$ whenever $H^{\prime}=\left(\left(a^{\prime}_{\sigma(t)},\,r^{\prime}_{\sigma(t)}\right):\;tâ[T]\right)$ for some permutation $\sigma$ of $[t]$ .*
**Remark 3.3**
*Lemma 3.1 should not be taken for granted. Indeed, there are two very natural extensions of Bayesian update for which this lemma does not hold. First, suppose we condition on an arbitrary observable event. That is, fix a set $\mathcal{H}$ of feasible $t$ -histories. For any algorithm with $\Pr[H_{t}â\mathcal{H}]>0$ , consider the posterior distribution given the event $\{H_{t}â\mathcal{H}\}$ :
$$
\displaystyle\Pr[\mu\in\mathcal{M}\mid H_{t}\in\mathcal{H}],\quad\forall\mathcal{M}\subset[0,1]^{K}. \tag{37}
$$
This distribution may depend on the bandit algorithm. For a simple example, consider a problem instance with Bernoulli rewards, three arms $\mathcal{A}=\{a,a^{\prime},a^{\prime\prime}\}$ , and a single round. Say $\mathcal{H}$ consists of two feasible $1$ -histories, $H=(a,1)$ and $H^{\prime}=(a^{\prime},1)$ . Two algorithms, $\mathtt{ALG}$ and $\mathtt{ALG}^{\prime}$ , deterministically choose arms $a$ and $a^{\prime}$ , respectively. Then the distribution (37) equals $\mathbb{P}_{H}$ under $\mathtt{ALG}$ , and $\mathbb{P}_{H^{\prime}}$ under $\mathtt{ALG}^{\prime}$ . Second, suppose we condition on a subset of rounds. The algorithmâs history for a subset $Sâ[T]$ of rounds, called $S$ -history, is an ordered tuple
$$
\displaystyle H_{S}=((a_{t},r_{t}):\,t\in S)\in(\mathcal{A}\times\mathbb{R})^{|S|}. \tag{38}
$$
For any feasible $|S|$ -history $H$ , the posterior distribution given the event $\{H_{S}=H\}$ , denoted $\mathbb{P}_{H,S}$ , is
$$
\displaystyle\mathbb{P}_{H,S}(\mathcal{M}):=\Pr[\mu\in\mathcal{M}\mid H_{S}=H],\quad\forall\mathcal{M}\subset[0,1]^{K}. \tag{39}
$$
However, this distribution may depend on the bandit algorithm, too. Consider a problem instance with Bernoulli rewards, two arms $\mathcal{A}=\{a,a^{\prime}\}$ , and two rounds. Let $S=\{2\}$ (i.e., we only condition on what happens in the second round), and $H=(a,1)$ . Consider two algorithms, $\mathtt{ALG}$ and $\mathtt{ALG}^{\prime}$ , which choose different arms in the first round (say, $a$ for $\mathtt{ALG}$ and $a^{\prime}$ for $\mathtt{ALG}^{\prime}$ ), and choose arm $a$ in the second round if and only if they receive a reward of $1$ in the first round. Then the distribution (39) additionally conditions on $H_{1}=(a,1)$ under $\mathtt{ALG}$ , and on on $H_{1}=(a^{\prime},1)$ under $\mathtt{ALG}^{\prime}$ .*
15.3 Posterior as a new prior
The posterior $\mathbb{P}_{H}$ can be used as a prior for a subsequent Bayesian update. Consider a feasible $(t+t^{\prime})$ -history, for some $t^{\prime}$ . Represent it as a concatenation of $H$ and another feasible $t^{\prime}$ -history $H^{\prime}$ , where $H$ comes first. Denote such concatenation as $H\oplus H^{\prime}$ . Thus, we have two events:
$$
\{H_{t}=H\}\text{ and }\{H_{S}=H^{\prime}\}\text{,~~where }S=[t+t^{\prime}]\setminus[t].
$$
(Here $H_{S}$ follows the notation from (38).) We could perform the Bayesian update in two steps: (i) condition on $H$ and derive the posterior $\mathbb{P}_{H}$ , and (ii) condition on $H^{\prime}$ using $\mathbb{P}_{H}$ as the new prior. In our notation, the resulting posterior can be written compactly as $(\mathbb{P}_{H})_{H^{\prime}}$ . We prove that the âtwo-stepâ Bayesian update described above is equivalent to the âone-stepâ update given $H\oplus H^{\prime}$ . In a formula, $\mathbb{P}_{H\oplus H^{\prime}}=(\mathbb{P}_{H})_{H^{\prime}}$ .
**Lemma 3.4**
*Let $H^{\prime}$ be a feasible $t^{\prime}$ -history. Then $\mathbb{P}_{H\oplus H^{\prime}}=(\mathbb{P}_{H})_{H^{\prime}}$ . More explicitly:
$$
\displaystyle\mathbb{P}_{H\oplus H^{\prime}}(\mathcal{M})=\Pr_{\mu\sim\mathbb{P}_{H}}[\mu\in\mathcal{M}\mid H_{t^{\prime}}=H^{\prime}],\quad\forall\mathcal{M}\subset[0,1]^{K}. \tag{40}
$$*
One take-away is that $\mathbb{P}_{H}$ encompasses all pertinent information from $H$ , as far as mean rewards are concerned. In other words, once $\mathbb{P}_{H}$ is computed, one can forget about $\mathbb{P}$ and $H$ going forward.
The proof is a little subtle: it relies on the $(H\oplus H^{\prime})$ -induced algorithm for the main argument, and carefully applies Lemma 3.1 to extend to arbitrary bandit algorithms.
* Proof*
It suffices to prove the lemma for a singleton set $\mathcal{M}=\{\tilde{\mu}\}$ , for any given vector $\tilde{\mu}â\mathcal{F}$ . Let $\mathtt{ALG}$ be the $(H\oplus H^{\prime})$ -induced algorithm. Let $H^{\mathtt{ALG}}_{t}$ denote its $t$ -history, and let $H^{\mathtt{ALG}}_{S}$ denote its $S$ -history, where $S=[t+t^{\prime}]\setminus[t]$ . We will prove that
$$
\displaystyle\mathbb{P}_{H\oplus H^{\prime}}(\mu=\tilde{\mu})=\Pr_{\mu\sim\mathbb{P}_{H}}[\mu=\tilde{\mu}\mid H^{\mathtt{ALG}}_{S}=H^{\prime}]. \tag{41}
$$ We are interested in two events:
$$
\mathcal{E}_{t}=\{H^{\mathtt{ALG}}_{t}=H\}\text{ and }\mathcal{E}_{S}=\{H^{\mathtt{ALG}}_{S}=H^{\prime}\}.
$$
Write $\mathbb{Q}$ for $\Pr_{\mu\sim\mathbb{P}_{H}}$ for brevity. We prove that $\mathbb{Q}[·]=\Pr[\,·\mid\mathcal{E}_{t}]$ for some events of interest. Formally,
| | $\displaystyle\mathbb{Q}[\mu=\tilde{\mu}]$ | $\displaystyle=\mathbb{P}[\mu=\tilde{\mu}\mid\mathcal{E}_{t}]$ | (by definition of $\mathbb{P}_{H}$ ) | |
| --- | --- | --- | --- | --- |
Summing up over all $\tilde{\mu}â\mathcal{F}$ , we obtain:
| | $\displaystyle\textstyle\mathbb{Q}[\mathcal{E}_{S}]=\sum_{\tilde{\mu}â\mathcal{F}}\,\mathbb{Q}[\mathcal{E}_{S}\text{ and }\mu=\tilde{\mu}]=\sum_{\tilde{\mu}â\mathcal{F}}\,\Pr[\mathcal{E}_{S}\text{ and }\mu=\tilde{\mu}\mid\mathcal{E}_{t}]=\Pr[\mathcal{E}_{S}\mid\mathcal{E}_{t}].$ | |
| --- | --- | --- |
Now, the right-hand side of (41) is
| | $\displaystyle\mathbb{Q}[\mu=\tilde{\mu}\mid\mathcal{E}_{S}]$ | $\displaystyle=\frac{\mathbb{Q}[\mu=\tilde{\mu}\text{ and }\mathcal{E}_{S}]}{\mathbb{Q}[\mathcal{E}_{S}]}=\frac{\Pr[\mathcal{E}_{S}\text{ and }\mu=\tilde{\mu}\mid\mathcal{E}_{t}]}{\Pr[\mathcal{E}_{S}\mid\mathcal{E}_{t}]}=\frac{\Pr[\mathcal{E}_{t}\text{ and }\mathcal{E}_{S}\text{ and }\mu=\tilde{\mu}]}{\Pr[\mathcal{E}_{t}\text{ and }\mathcal{E}_{S}]}$ | |
| --- | --- | --- | --- |
The latter equals $\mathbb{P}_{H\oplus H^{\prime}}(\mu=\tilde{\mu})$ , proving (41). It remains to switch from $\mathtt{ALG}$ to an arbitrary bandit algorithm. We apply Lemma 3.1 twice, to both sides of (41). The first application is simply that $\mathbb{P}_{H\oplus H^{\prime}}(\mu=\tilde{\mu})$ does not depend on the bandit algorithm. The second application is for prior distribution $\mathbb{P}_{H}$ and feasible $t^{\prime}$ -history $H^{\prime}$ . Let $\mathtt{ALG}^{\prime}$ be the $H^{\prime}$ -induced algorithm $\mathtt{ALG}^{\prime}$ , and let $H^{\mathtt{ALG}^{\prime}}_{t^{\prime}}$ be its $t^{\prime}$ -history. Then
$$
\displaystyle\Pr_{\mu\sim\mathbb{P}_{H}}[\mu=\tilde{\mu}\mid H^{\mathtt{ALG}}_{S}=H^{\prime}]=\Pr_{\mu\sim\mathbb{P}_{H}}[\mu=\tilde{\mu}\mid H^{\mathtt{ALG}^{\prime}}_{t^{\prime}}=H^{\prime}]=\Pr_{\mu\sim\mathbb{P}_{H}}[\mu=\tilde{\mu}\mid H_{t^{\prime}}=H^{\prime}]. \tag{42}
$$
The second equality is by Lemma 3.1. We defined $\mathtt{ALG}^{\prime}$ to switch from the $S$ -history to the $t^{\prime}$ -history. Thus, weâve proved that the right-hand side of (42) equals $\mathbb{P}_{H\oplus H^{\prime}}(\mu=\tilde{\mu})$ for an arbitrary bandit algorithm. â
15.4 Independent priors
Bayesian update simplifies for for independent priors: essentially, each arm can be updated separately. More formally, the prior $\mathbb{P}$ is called independent if $(\mu(a):aâ\mathcal{A})$ are mutually independent random variables.
Fix some feasible $t$ -history $H$ , as per (35). Let $S_{a}=\{sâ[t]:\,a^{\prime}_{s}=a\}$ be the subset of rounds when a given arm $a$ is chosen, according to $H$ . The portion of $H$ that concerns arm $a$ is defined as an ordered tuple
$$
\mathtt{proj}(H;a)=((a^{\prime}_{s},r^{\prime}_{s}):\,s\in S_{a}).
$$
We think of $\mathtt{proj}(H;a)$ as a projection of $H$ onto arm $a$ , and call it projected history for arm $a$ . Note that it is itself a feasible $|S_{a}|$ -history. Define the posterior distribution $\mathbb{P}^{a}_{H}$ for arm $a$ :
$$
\displaystyle\mathbb{P}^{a}_{H}(\mathcal{M}_{a}) \displaystyle:=\mathbb{P}_{\mathtt{proj}(H;a)}(\mu(a)\in\mathcal{M}_{a}),\quad\forall\mathcal{M}_{a}\subset[0,1]. \tag{43}
$$
$\mathbb{P}^{a}_{H}$ does not depend on the bandit algorithm, by Lemma 3.1. Further, for the $H$ -induced algorithm
$$
\mathbb{P}^{a}_{H}(\mathcal{M}_{a})=\Pr[\mu(a)\in\mathcal{M}_{a}\mid\mathtt{proj}(H_{t};a)=\mathtt{proj}(H;a)].
$$
Now we are ready for a formal statement:
**Lemma 3.5**
*Assume the prior $\mathbb{P}$ is independent. Fix a subset $\mathcal{M}_{a}â[0,1]$ for each arm $aâ\mathcal{A}$ . Then
| | $\displaystyle\mathbb{P}_{H}(\cap_{aâ\mathcal{A}}\,\mathcal{M}_{a})$ | $\displaystyle=\prod_{aâ\mathcal{A}}\,\mathbb{P}^{a}_{H}(\mathcal{M}_{a}).$ | |
| --- | --- | --- | --- |*
* Proof*
The only subtlety is that we focus the $H$ -induced bandit algorithm. Then the pairs $(\mu(a),\mathtt{proj}(H_{t};a))$ , $aâ\mathcal{A}$ are mutually independent random variables. We are interested in these two events, for each arm $a$ :
| | $\displaystyle\mathcal{E}_{a}$ | $\displaystyle=\{\mu(a)â\mathcal{M}_{a}\}$ | |
| --- | --- | --- | --- |
Letting $\mathcal{M}=\cap_{aâ\mathcal{A}}\,\mathcal{M}_{a}$ , we have:
| | $\displaystyle\Pr[H_{t}=H\text{ and }\muâ\mathcal{M}]$ | $\displaystyle=\Pr\left[\bigcap_{aâ\mathcal{A}}(\mathcal{E}_{a}\cap\mathcal{E}_{a}^{H})\right]=\prod_{aâ\mathcal{A}}\Pr\left[\mathcal{E}_{a}\cap\mathcal{E}_{a}^{H}\right].$ | |
| --- | --- | --- | --- |
Likewise, $\Pr[H_{t}=H]=\prod_{aâ\mathcal{A}}\Pr[\mathcal{E}_{a}^{H}]$ . Putting this together,
| | $\displaystyle\mathbb{P}_{H}(\mathcal{M})$ | $\displaystyle=\frac{\Pr[H_{t}=H\text{ and }\muâ\mathcal{M}]}{\Pr[H_{t}=H]}=\prod_{aâ\mathcal{A}}\frac{\Pr[\mathcal{E}_{a}\cap\mathcal{E}_{a}^{H}]}{\Pr[\mathcal{E}_{a}^{H}]}$ | |
| --- | --- | --- | --- |
16 Algorithm specification and implementation
Consider a simple algorithm for Bayesian bandits, called Thompson Sampling. For each round $t$ and arm $a$ , the algorithm computes the posterior probability that $a$ is the best arm, and samples $a$ with this probability.
for each round $t=1,2,...$ do
Observe $H_{t-1}=H$ , for some feasible $(t-1)$ -history $H$ ;
Draw arm $a_{t}$ independently from distribution $p_{t}(·\,|H)$ , where
$$
p_{t}(a\mid H):=\Pr[a^{*}=a\mid H_{t-1}=H]\quad\text{for each arm $a$}.
$$
end for
Algorithm 1 Thompson Sampling.
**Remark 3.6**
*The probabilities $p_{t}(·\mid H)$ are determined by $H$ , by Lemma 3.1.*
Thompson Sampling admits an alternative characterization:
for each round $t=1,2,...$ do
Observe $H_{t-1}=H$ , for some feasible $(t-1)$ -history $H$ ;
Sample mean reward vector $\mu_{t}$ from the posterior distribution $\mathbb{P}_{H}$ ;
Choose the best arm $\tilde{a}_{t}$ according to $\mu_{t}$ .
end for
Algorithm 2 Thompson Sampling: alternative characterization.
It is easy to see that this characterization is in fact equivalent to the original algorithm.
**Lemma 3.7**
*For each round $t$ , arms $a_{t}$ and $\tilde{a}_{t}$ are identically distributed given $H_{t}$ .*
* Proof*
Fix a feasible $t$ -history $H$ . For each arm $a$ we have:
| | $\displaystyle\Pr[\tilde{a}_{t}=a\mid H_{t-1}=H]$ | $\displaystyle=\mathbb{P}_{H}(a^{*}=a)$ | (by definition of $\tilde{a}_{t}$ ) | |
| --- | --- | --- | --- | --- |
The algorithm further simplifies when we have independent priors. By Lemma 3.5, it suffices to consider the posterior distribution $\mathbb{P}^{a}_{H}$ for each arm $a$ separately, as per (43).
for each round $t=1,2,...$ do
Observe $H_{t-1}=H$ , for some feasible $(t-1)$ -history $H$ ;
For each arm $a$ , sample mean reward $\mu_{t}(a)$ independently from distribution $\mathbb{P}_{H}^{a}$ ;
Choose an arm with largest $\mu_{t}(a)$ .
end for
Algorithm 3 Thompson Sampling for independent priors.
16.1 Computational aspects
While Thompson Sampling is mathematically well-defined, it may be computationally inefficient. Indeed, let us consider a brute-force computation for the round- $t$ posterior $\mathbb{P}_{H}$ :
$$
\displaystyle\mathbb{P}_{H}(\tilde{\mu})=\frac{\Pr[\mu=\tilde{\mu}\text{ and }H_{t}=H]}{\mathbb{P}(H_{t}=H)}=\frac{\mathbb{P}(\tilde{\mu})\cdot\Pr[H_{t}=H\mid\mu=\tilde{\mu}]}{\sum_{\tilde{\mu}\in\mathcal{F}}\mathbb{P}(\tilde{\mu})\cdot\Pr[H_{t}=H\mid\mu=\tilde{\mu}]},\quad\forall\tilde{\mu}\in\mathcal{F}. \tag{44}
$$
Since $\Pr[H_{t}=H\mid\mu=\tilde{\mu}]$ can be computed in time $O(t)$ , Here and elsewhere, we count addition and multiplication as unit-time operations. the probability $\mathbb{P}(H_{t}=H)$ can be computed in time $O(t·|\mathcal{F}|)$ . Then the posterior probabilities $\mathbb{P}_{H}(·)$ and the sampling probabilities $p_{t}(·\mid H)$ can be computed by a scan through all $\tilde{\mu}â\mathcal{F}$ . Thus, a brute-force implementation of Algorithm 1 or Algorithm 2 takes at least $O(t·|\mathcal{F}|)$ running time in each round $t$ , which may be prohibitively large.
A somewhat faster computation can be achieved via a sequential Bayesian update. After each round $t$ , we treat the posterior $\mathbb{P}_{H}$ as a new prior. We perform a Bayesian update given the new data point $(a_{t},r_{t})=(a,r)$ , to compute the new posterior $\mathbb{P}_{H\oplus(a,r)}$ . This approach is sound by Lemma 3.4. The benefit in terms of the running time is that in each round the update is on the history of length $1$ . In particular, with similar brute-force approach as in (44), the per-round running time improves to $O(|\mathcal{F}|)$ .
**Remark 3.8**
*While weâd like to have both low regret and a computationally efficient implementation, either one of the two may be interesting: a slow algorithm can serve as a proof-of-concept that a given regret bound can be achieved, and a fast algorithm without provable regret bounds can still perform well in practice.*
With independent priors, one can do the sequential Bayesian update for each arm $a$ separately. More formally, fix round $t$ , and suppose in this round $(a_{t},r_{t})=(a,r)$ . One only needs to update the posterior for $\mu(a)$ . Letting $H=H_{t}$ be the realized $t$ -history, treat the current posterior $\mathbb{P}_{H}^{a}$ as a new prior, and perform a Bayesian update to compute the new posterior $\mathbb{P}_{H^{\prime}}^{a}$ , where $H^{\prime}=H\oplus(a,r)$ . Then:
$$
\displaystyle\mathbb{P}_{H^{\prime}}^{a}(x)=\Pr_{\mu(a)\sim\mathbb{P}_{H}^{a}}[\mu(a)=x\mid(a_{t},r_{t})=(a,r)]=\frac{\mathbb{P}_{H}^{a}(x)\cdot\mathcal{D}_{x}(r)}{\sum_{x\in\mathcal{F}_{a}}\;\mathbb{P}_{H}^{a}(x)\cdot\mathcal{D}_{x}(r)},\quad\forall x\in\mathcal{F}_{a}, \tag{45}
$$
where $\mathcal{F}_{a}$ is the support of $\mu(a)$ . Thus, the new posterior $\mathbb{P}_{H^{\prime}}^{a}$ can be computed in time $O(|\mathcal{F}_{a}|)$ . This is an exponential speed-up compared $|\mathcal{F}|$ (in a typical case when $|\mathcal{F}|â\prod_{a}|\mathcal{F}_{a}|$ ).
Special cases. Some special cases admit much faster computation of the posterior $\mathbb{P}^{a}_{H}$ and much faster sampling therefrom. Here are two well-known special cases when this happens. For both cases, we relax the problem setting so that the mean rewards can take arbitrarily real values.
To simplify our notation, posit that there is only one arm $a$ . Let $\mathbb{P}$ be the prior on its mean reward $\mu(a)$ . Let $H$ be a feasible $t$ -history $H$ , and let $\mathtt{REW}_{H}$ denote the total reward in $H$ .
Beta-Bernoulli
Assume Bernoulli rewards. By Corollary 3.2, the posterior $\mathbb{P}_{H}$ is determined by the prior $\mathbb{P}$ , the number of samples $t$ , and the total reward $\mathtt{REW}_{H}$ . Suppose the prior is the uniform distribution on the $[0,1]$ interval, denoted $\mathbb{U}$ . Then the posterior $\mathbb{U}_{H}$ is traditionally called Beta distribution with parameters $\alpha=1+\mathtt{REW}_{H}$ and $\beta=1+t$ , and denoted $\mathtt{Beta}(\alpha,\beta)$ . For consistency, $\mathtt{Beta}(1,1)=\mathbb{U}$ : if $t=0$ , the posterior $\mathbb{U}_{H}$ given the empty history $H$ is simply the prior $\mathbb{U}$ .
A Beta-Bernoulli conjugate pair is a combination of Bernoulli rewards and a prior $\mathbb{P}=\mathtt{Beta}(\alpha_{0},\beta_{0})$ for some parameters $\alpha_{0},\beta_{0}â\mathbb{N}$ . The posterior $\mathbb{P}_{H}$ is simply $\mathtt{Beta}(\alpha_{0}+\mathtt{REW}_{H},\beta_{0}+t)$ . This is because $\mathbb{P}=\mathbb{U}_{H_{0}}$ for an appropriately chosen feasible history $H_{0}$ , and $\mathbb{P}_{H}=\mathbb{U}_{H_{0}\oplus H}$ by Lemma 3.4.
(Corollary 3.2 and Lemma 3.4 extend to priors $\mathbb{P}$ with infinite support, including Beta distributions.) Gaussians
A Gaussian conjugate pair is a combination of a Gaussian reward distribution and a Gaussian prior $\mathbb{P}$ . Letting $\mu,\mu_{0}$ be their resp. means, $\sigma,\sigma_{0}$ be their resp. standard deviations, the posterior $\mathbb{P}_{H}$ is also a Gaussian whose mean and standard deviation are determined (via simple formulas) by the parameters $\mu,\mu_{0},\sigma,\sigma_{0}$ and the summary statistics $\mathtt{REW}_{H},t$ of $H$ .
Beta distributions and Gaussians are well-understood. In particular, very fast algorithms exist to sample from either family of distributions.
17 Bayesian regret analysis
Let us analyze Bayesian regret of Thompson Sampling, by connecting it to the upper and lower confidence bounds studied in Chapter 1. We prove:
**Theorem 3.9**
*Bayesian Regret of Thompson Sampling is $\mathtt{BR}(T)=O(\sqrt{KT\log(T)})$ .*
Let us recap some of the definitions from Chapter 1: for each arm $a$ and round $t$ ,
$$
\displaystyle r_{t}(a) \displaystyle=\sqrt{2\cdot\log(T)\,/\,n_{t}(a)} \displaystyle\mathtt{UCB}_{t}(a) \displaystyle=\bar{\mu}_{t}(a)+r_{t}(a) \displaystyle\mathtt{LCB}_{t}(a) \displaystyle=\bar{\mu}_{t}(a)-r_{t}(a) \displaystyle\text{\emph{(lower confidence bound)}}. \tag{46}
$$
Here, $n_{t}(a)$ is the number of times arm $a$ has been played so far, and $\bar{\mu}_{t}(a)$ is the average reward from this arm. As weâve seen before, $\mu(a)â\left[\,\mathtt{LCB}_{t}(a),\>\mathtt{UCB}_{t}(a)\,\right]$ with high probability.
The key lemma in the proof of Theorem 3.9 holds for a more general notion of the confidence bounds, whereby they can be arbitrary functions of the arm $a$ and the $t$ -history $H_{t}$ : respectively, $U(a,\>H_{t})$ and $L(a,\>H_{t})$ . There are two properties we want these functions to have, for some $\gamma>0$ to be specified later: As a matter of notation, $x^{-}$ is the negative portion of the number $x$ , i.e., $x^{-}=0$ if $xâ„ 0$ , and $x^{-}=|x|$ otherwise.
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}\left[\,\left[\,U(a,\,H_{t})-\mu(a)\,\right]^{-}\,\right] \displaystyle\leq\tfrac{\gamma}{TK} \displaystyle\quad\text{for all arms $a$ and rounds $t$}, \displaystyle\operatornamewithlimits{\mathbb{E}}\left[\,\left[\,\mu(a)-L(a,\,H_{t})\,\right]^{-}\,\right] \displaystyle\leq\tfrac{\gamma}{TK} \displaystyle\quad\text{for all arms $a$ and rounds $t$}. \tag{47}
$$
The first property says that the upper confidence bound $U$ does not exceed the mean reward by too much in expectation, and the second property makes a similar statement about $L$ . As usual, $K$ denotes the number of arms. The confidence radius can be defined as $r(a,\>H_{t})=\frac{U(a,\>H_{t})-L(a,\>H_{t})}{2}$ .
**Lemma 3.10**
*Assume we have lower and upper bound functions that satisfy properties $(\ref{TS:eq:prop1})$ and $(\ref{TS:eq:prop2})$ , for some parameter $\gamma>0$ . Then Bayesian Regret of Thompson Sampling can be bounded as follows:
| | $\displaystyle\mathtt{BR}(T)â€\textstyle 2\gamma+2\sum_{t=1}^{T}\operatornamewithlimits{\mathbb{E}}\left[\,r(a_{t},\>H_{t})\,\right].$ | |
| --- | --- | --- |*
* Proof*
Fix round $t$ . Interpreted as random variables, the chosen arm $a_{t}$ and the best arm $a^{*}$ are identically distributed given $t$ -history $H_{t}$ : for each feasible $t$ -history $H$ ,
| | $\displaystyle\Pr[a_{t}=a\mid H_{t}=H]=\Pr[a^{*}=a\mid H_{t}=H]\quad\text{for each arm $a$}.$ | |
| --- | --- | --- |
It follows that
$$
\operatornamewithlimits{\mathbb{E}}[\>U(a^{*},\>H)\>\mid\>H_{t}=H\>]=\operatornamewithlimits{\mathbb{E}}[\>U(a_{t},\>H)\>\mid\>H_{t}=H\>]. \tag{49}
$$
Then Bayesian Regret suffered in round $t$ is
$$
\displaystyle\mathtt{BR}_{t} \displaystyle:=\operatornamewithlimits{\mathbb{E}}\left[\,\mu(a^{*})-\mu(a_{t})\,\right] \displaystyle=\operatornamewithlimits{\mathbb{E}}_{H\sim H_{t}}\left[\,\operatornamewithlimits{\mathbb{E}}\left[\,\mu(a^{*})-\mu(a_{t})\mid H_{t}=H\,\right]\,\right] \displaystyle=\operatornamewithlimits{\mathbb{E}}_{H\sim H_{t}}\left[\,\operatornamewithlimits{\mathbb{E}}\left[\,U(a_{t},H)-\mu(a_{t})+\mu(a^{*})-U(a^{*},H)\mid H_{t}=H\,\right]\,\right] \displaystyle=\underbrace{\operatornamewithlimits{\mathbb{E}}\left[\,U(a_{t},H_{t})-\mu(a_{t})\,\right]}_{\text{Summand 1}}+\underbrace{\operatornamewithlimits{\mathbb{E}}\left[\,\mu(a^{*})-U(a^{*},H_{t})\,\right]}_{\text{Summand 2}}. \tag{49}
$$ We will use properties (47) and (48) to bound both summands. Note that we cannot immediately use these properties because they assume a fixed arm $a$ , whereas both $a_{t}$ and $a^{*}$ are random variables. $$
\displaystyle\operatornamewithlimits{\mathbb{E}}\left[\,\mu(a^{*})-U(a^{*},H_{t})\,\right] \displaystyle\leq\operatornamewithlimits{\mathbb{E}}\left[\,(\mu(a^{*})-U(a^{*},H_{t}))^{+}\,\right] \displaystyle\leq\operatornamewithlimits{\mathbb{E}}\left[\,\sum_{\text{arms $a$}}\left[\,\mu(a)-U(a,H_{t})\,\right]^{+}\,\right] \displaystyle=\textstyle\sum_{\text{arms $a$}}\operatornamewithlimits{\mathbb{E}}\left[\,\left(\,U(a,H_{t})-\mu(a)\,\right)^{-}\,\right] \displaystyle\leq K\cdot\frac{\gamma}{KT}=\frac{\gamma}{T} \displaystyle\text{\emph{(by property (\ref{TS:eq:prop1}))}}. \displaystyle\operatornamewithlimits{\mathbb{E}}\left[\,U(a_{t},H_{t})-\mu(a_{t})\,\right] \displaystyle=\operatornamewithlimits{\mathbb{E}}\left[\,2r(a_{t},H_{t})+L(a_{t},H_{t})-\mu(a_{t})\,\right] \displaystyle=\operatornamewithlimits{\mathbb{E}}\left[\,2r(a_{t},H_{t})\,\right]+\operatornamewithlimits{\mathbb{E}}\left[\,L(a_{t},H_{t})-\mu(a_{t})\,\right] \displaystyle\operatornamewithlimits{\mathbb{E}}[L(a_{t},H_{t})-\mu(a_{t})] \displaystyle\leq\operatornamewithlimits{\mathbb{E}}\left[\,\left(\,L(a_{t},H_{t})-\mu(a_{t})\,\right)^{+}\,\right] \displaystyle\leq\operatornamewithlimits{\mathbb{E}}\left[\,\sum_{\text{arms $a$}}\left(\,L(a,H_{t})-\mu(a)\,\right)^{+}\,\right] \displaystyle=\underset{\text{arms $a$}}{\sum}\operatornamewithlimits{\mathbb{E}}\left[\,\left(\,\mu(a)-L(a,H_{t})\,\right)^{-}\,\right] \displaystyle\leq K\cdot\frac{\gamma}{KT}=\frac{\gamma}{T} \displaystyle\text{\emph{(by property (\ref{TS:eq:prop2}))}}. \tag{47}
$$ Thus, $\mathtt{BR}_{t}(T)†2\tfrac{\gamma}{T}+2\,\operatornamewithlimits{\mathbb{E}}[r(a_{t},H_{t})]$ . The theorem follows by summing up over all rounds $t$ . â
**Remark 3.11**
*Thompson Sampling does not need to know what $U$ and $L$ are!*
**Remark 3.12**
*Lemma 3.10 does not rely on any specific structure of the prior. Moreover, it can be used to upper-bound Bayesian regret of Thompson Sampling for a particular class of priors whenever one has âniceâ confidence bounds $U$ and $L$ for this class.*
* Proof of Theorem3.9*
Let us use the confidence bounds and the confidence radius from (46). Note that they satisfy properties $(\ref{TS:eq:prop1})$ and $(\ref{TS:eq:prop2})$ with $\gamma=2$ . By Lemma 3.10,
| | $\displaystyle\mathtt{BR}(T)†O\left(\,\sqrt{\log T}\,\right)\sum_{t=1}^{T}\operatornamewithlimits{\mathbb{E}}\left[\;\frac{1}{\sqrt{n_{t}(a_{t})}}\;\right].$ | |
| --- | --- | --- |
Moreover,
| | $\displaystyle\sum_{t=1}^{T}\sqrt{\frac{1}{n_{t}(a_{t})}}$ | $\displaystyle=\sum_{\text{\text{arms $a$}}}\quad\sum_{\text{rounds $t$:\; $a_{t}=a$}}\;\;\frac{1}{\sqrt{n_{t}(a)}}$ | |
| --- | --- | --- | --- |
It follows that
| | $\displaystyle\mathtt{BR}(T)$ | $\displaystyle†O\left(\,\sqrt{\log T}\,\right)\underset{\text{arms $a$}}{\sum}\sqrt{n(a)}†O\left(\,\sqrt{\log T}\,\right)\sqrt{K\underset{\text{arms $a$}}{\sum}n(a)}=O\left(\,\sqrt{KT\log T}\,\right),$ | |
| --- | --- | --- | --- |
where the intermediate step is by the arithmetic vs. quadratic mean inequality. â
18 Thompson Sampling with no prior (and no proofs)
Thompson Sampling can also be used for the original problem of stochastic bandits, i.e., the problem without a built-in prior $\mathbb{P}$ . Then $\mathbb{P}$ is a âfake priorâ: just a parameter to the algorithm, rather than a feature of reality. Prior work considered two such âfake priorsâ:
- independent uniform priors and 0-1 rewards.
- independent standard Gaussian priors and unit-variance Gaussian rewards.
**Remark 3.13**
*Under both approaches, the prior specifies the âshapeâ of the reward distributions: resp., Bernoulli and unit-variance Gaussian. However, this prior is just a parameter in the algorithm, and does not imply an assumption on the actual reward distributions. In particular, whenever some reward $r_{t}\notâ\left\{\,0,1\,\right\}$ is received under approach (i), one flips a random coin with expectation $r_{t}$ , and pass the outcome of this coin flip to Thompson Sampling (so that the input is consistent with the prior). Approach (ii) treats the realized rewards as if they are generated by a unit-variance Gaussian.*
Let us state the regret bounds for both approaches.
**Theorem 3.14**
*Thompson Sampling, with approach (i) or (ii), achieves expected regret
$$
\operatornamewithlimits{\mathbb{E}}[R(T)]\leq O(\sqrt{KT\log{T}}).
$$*
**Theorem 3.15**
*For each problem instance, Thompson Sampling with approach (i) achieves, for all $\epsilon>0$ ,
| | $\displaystyle\operatornamewithlimits{\mathbb{E}}[R(T)]â€(1+\epsilon)\,C\,\log(T)+\frac{f(\mu)}{\epsilon^{2}},\quad\text{where}\quad C=\sum_{\text{arms $a$}:\,\Delta(a)<0}\;\frac{\mu(a^{*})-\mu(a)}{\mathtt{KL}(\mu(a),\mu^{*})}.$ | |
| --- | --- | --- |
Here $f(\mu)$ depends on the mean reward vector $\mu$ , but not on $\epsilon$ or $T$ .*
The $C$ term is the optimal constant in the regret bounds: it matches the constant in Theorem 2.16. This is a partial explanation for why Thompson Sampling is so good in practice. However, this is not a full explanation because the term $f(\mu)$ can be quite big, as far as one can prove.
19 Literature review and discussion
Thompson Sampling is the first bandit algorithm in the literature (Thompson, 1933). While it has been well-known for a long time, strong provable guarantees did not appear until recently. A detailed survey for various variants and developments can be found in Russo et al. (2018).
The material in Section 17 is from Russo and Van Roy (2014). Lemma 3.10 follows from Russo and Van Roy (2014), making their technique more transparent. They refine this approach to obtain improved upper bounds for some specific classes of priors, including priors over linear and âgeneralized linearâ mean reward vectors, and priors given by a Gaussian Process. Bubeck and Liu (2013) obtain $O(\sqrt{KT})$ regret for arbitrary priors, shaving off the $\log(T)$ factor from Theorem 3.9. Russo and Van Roy (2016) obtain regret bounds that scale with the entropy of the optimal-action distribution induced by the prior.
The prior-independent results in Section 18 are from (Agrawal and Goyal, 2012, 2013, 2017) and Kaufmann et al. (2012). The first âprior-independentâ regret bound for Thompson Sampling, a weaker version of Theorem 3.15, has appeared in Agrawal and Goyal (2012). Theorem 3.14 is from Agrawal and Goyal (2013, 2017). For standard-Gaussian priors, Agrawal and Goyal (2013, 2017) achieve a slightly stronger version, $O(\sqrt{KT\log K})$ . They also prove a matching lower bound for the Bayesian regret of Thompson Sampling for standard-Gaussian priors. Theorem 3.15 is from (Kaufmann et al., 2012; Agrawal and Goyal, 2013, 2017). Kaufmann et al. (2012) prove a slightly weaker version in which $\ln(T)$ is replaced with $\ln(T)+\ln\ln(T)$ .
Bubeck et al. (2015); Zimmert and Lattimore (2019); Bubeck and Sellke (2020) extend Thompson Sampling to adversarial bandits (which are discussed in Chapter 6). In particular, variants of the algorithm have been used in some of the recent state-of-art results on bandits (Bubeck et al., 2015; Zimmert and Lattimore, 2019), building on the analysis technique from Russo and Van Roy (2016).
Chapter 4 Bandits with Similarity Information
We consider stochastic bandit problems in which an algorithm has auxiliary information on similarity between arms. We focus on Lipschitz bandits, where the similarity information is summarized via a Lipschitz constraint on the expected rewards. Unlike the basic model in Chapter 1, Lipschitz bandits remain tractable even if the number of arms is very large or infinite.
Prerequisites: Chapter 1; Chapter 2 (results and construction only).
A bandit algorithm may have auxiliary information on similarity between arms, so that âsimilarâ arms have similar expected rewards. For example, arms can correspond to âitemsâ (e.g., documents) with feature vectors, and similarity between arms can be expressed as (some version of) distance between the feature vectors. Another example is dynamic pricing and similar problems, where arms correspond to offered prices for buying, selling or hiring; then similarity between arms is simply the difference between prices. In our third example, arms are configurations of a complex system, such as a server or an ad auction.
We capture these examples via an abstract model called Lipschitz bandits. We discuss some non-Lipschitz models of similarity in the literature review. In particular, the basic versions of dynamic pricing and similar problems naturally satisfy a 1-sided version of Lipschitzness, which suffices for our purposes. We consider stochastic bandits, as defined in Chapter 1. Specifically, the reward for each arm $x$ is an independent sample from some fixed but unknown distribution whose expectation is denoted $\mu(x)$ and realizations lie in $[0,1]$ . This basic model is endowed with auxiliary structure which expresses similarity. In the paradigmatic special case, called continuum-armed bandits, arms correspond to points in the interval $X=[0,1]$ , and expected rewards obey a Lipschitz condition:
$$
\displaystyle|\mu(x)-\mu(y)|\leq L\cdot|x-y|\quad\text{for any two arms $x,y\in X$}, \tag{50}
$$
where $L$ is a constant known to the algorithm. A function $\mu:Xâ\mathbb{R}$ which satisfies (50) is called Lipschitz-continuous on $X$ , with Lipschitz constant $L$ . In the general case, arms lie in an arbitrary metric space $(X,\mathcal{D})$ which is known to the algorithm, and the right-hand side in (50) is replaced with $\mathcal{D}(x,y)$ .
The technical material is organized as follows. We start with fundamental results on continuum-armed bandits. Then we present the general case of Lipschitz bandits and recover the same results; along the way, we present sufficient background on metric spaces. We proceed to develop a more advanced algorithm which takes advantage of âniceâ problem instances. Many auxiliary results are deferred to exercises, particularly those on lower bounds, metric dimensions, and dynamic pricing.
20 Continuum-armed bandits
To recap, continuum-armed bandits (CAB) is a version of stochastic bandits where the set of arms is the interval $X=[0,1]$ and mean rewards satisfy (50) with some known Lipschitz constant $L$ . Note that we have infinitely many arms, and in fact, continuously many. While bandit problems with a very large, let alone infinite, number of arms are hopeless in general, CAB is tractable due to the Lipschitz condition.
A problem instance is specified by reward distributions, time horizon $T$ , and Lipschitz constant $L$ . As usual, we are mainly interested in the mean rewards $\mu(·)$ as far as reward distributions are concerned, while the exact shape thereof is mostly unimportant. However, recall that some reward distributions allow for smaller confidence radii, e.g., see Exercise 1.1.
20.1 Simple solution: fixed discretization
A simple but powerful technique, called fixed discretization, works as follows. We pick a fixed, finite set of arms $Sâ X$ , called discretization of $X$ , and use this set as an approximation for $X$ . Then we focus only on arms in $S$ , and run an off-the-shelf algorithm $\mathtt{ALG}$ for stochastic bandits, such as $\mathtt{UCB1}$ or Successive Elimination, that only considers these arms. Adding more points to $S$ makes it a better approximation of $X$ , but also increases regret of $\mathtt{ALG}$ on $S$ . Thus, $S$ should be chosen so as to optimize this tradeoff.
The best arm in $S$ is denoted $\mu^{*}(S)=\sup_{xâ S}\mu(x)$ . In each round, algorithm $\mathtt{ALG}$ can only hope to approach expected reward $\mu^{*}(S)$ , and additionally suffers discretization error
$$
\displaystyle\mathtt{DE}(S)=\mu^{*}(X)-\mu^{*}(S). \tag{51}
$$
More formally, we can represent the algorithmâs expected regret as
| | $\displaystyle\operatornamewithlimits{\mathbb{E}}[R(T)]$ | $\displaystyle:=T·\mu^{*}(X)-W(\mathtt{ALG})$ | |
| --- | --- | --- | --- |
where $W(\mathtt{ALG})$ is the expected total reward of the algorithm, and $R_{S}(T)$ is the regret relative to $\mu^{*}(S)$ .
Let us assume that $\mathtt{ALG}$ attains the near-optimal regret rate from Chapter 1:
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}[R_{S}(T)]\leq c_{\mathtt{ALG}}\cdot\sqrt{|S|\,T\log T}\quad\text{for any subset of arms $S\subset X$}, \tag{52}
$$
where $c_{\mathtt{ALG}}$ is an absolute constant specific to $\mathtt{ALG}$ . Then
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}[R(T)]\leq c_{\mathtt{ALG}}\cdot\sqrt{|S|\,T\log T}+T\cdot\mathtt{DE}(S). \tag{53}
$$
This is a concrete expression for the tradeoff between the size of $S$ and its discretization error.
Uniform discretization divides the interval $[0,1]$ into intervals of fixed length $\epsilon$ , called discretization step, so that $S$ consists of all integer multiples of $\epsilon$ . It is easy to see that $\mathtt{DE}(S)†L\epsilon$ . Indeed, if $x^{*}$ is a best arm on $X$ , and $y$ is the closest arm to $x^{*}$ that lies in $S$ , it follows that $|x^{*}-y|â€\epsilon$ , and therefore $\mu(x^{*})-\mu(y)†L\epsilon$ . To optimize regret, we approximately equalize the two summands in (53).
**Theorem 4.1**
*Consider continuum-armed bandits with Lipschitz constant $L$ and time horizon $T$ . Uniform discretization with algorithm $\mathtt{ALG}$ satisfying (52) and discretization step $\epsilon=(TL^{2}/\log T)^{-1/3}$ attains
$$
\operatornamewithlimits{\mathbb{E}}[R(T)]\leq L^{1/3}\cdot T^{2/3}\cdot(1+c_{\mathtt{ALG}})(\log T)^{1/3}.
$$*
The main take-away here is the $\tilde{O}\left(\,L^{1/3}· T^{2/3}\,\right)$ regret rate. The explicit constant and logarithmic dependence are less important.
20.2 Lower Bound
Uniform discretization is in fact optimal in the worst case: we have an $\Omega\left(\,L^{1/3}· T^{2/3}\,\right)$ lower bound on regret. We prove this lower bound via a relatively simple reduction from the main lower bound, the $\Omega(\sqrt{KT})$ lower bound from Chapter 2, henceforth called $\mathtt{MainLB}$ .
The new lower bound involves problem instances with 0-1 rewards and the following structure. There is a unique best arm $x^{*}$ with $\mu(x^{*})=\nicefrac{{1}}{{2}}+\epsilon$ , where $\epsilon>0$ is a parameter to be adjusted later in the analysis. All arms $x$ have mean reward $\mu(x)=\nicefrac{{1}}{{2}}$ except those near $x^{*}$ . The Lipschitz condition requires a smooth transition between $x^{*}$ and the faraway arms; hence, we will have a âbumpâ around $x^{*}$ .
<details>
<summary>x1.png Details</summary>
### Visual Description
# Technical Document Extraction: Membership Function Plot
## 1. Component Isolation
* **Header/Top-Left:** Contains the vertical axis label.
* **Main Chart Area:** Contains a 2D coordinate system with a single green data series and a text annotation.
* **Footer/Bottom-Right:** Contains the horizontal axis label and domain definition.
## 2. Axis and Label Extraction
* **Vertical Axis (y-axis):**
* **Label:** $\mu(x)$ (typically denotes a membership function in fuzzy logic).
* **Markers:** A single numerical marker $\frac{1}{2}$ is located at the midpoint of the visible vertical axis.
* **Horizontal Axis (x-axis):**
* **Label/Domain:** $X = [0, 1]$ (indicates the universe of discourse is a closed interval from 0 to 1).
* **Embedded Text Annotation:**
* **Content:** "Hump near $x^*$"
* **Placement:** Centered directly above the triangular peak of the data series.
## 3. Data Series Analysis (Green Line)
* **Color:** Green.
* **Trend Verification:**
1. **Initial Phase:** The line starts at the y-axis at the height of $\frac{1}{2}$ and proceeds horizontally (constant slope of 0).
2. **Perturbation Phase:** The line encounters a "hump." It slopes upward to a local maximum and then slopes downward back to the original height.
3. **Final Phase:** The line resumes a horizontal path at the height of $\frac{1}{2}$ until the end of the visible domain.
* **Key Data Points:**
* **Baseline Value:** $\mu(x) = \frac{1}{2}$ for the majority of the domain.
* **Peak Value:** The "hump" reaches a peak height slightly above the $\frac{1}{2}$ marker.
* **Location of Peak:** Centered at a point designated as $x^*$ (based on the text annotation).
## 4. Technical Summary
The image depicts a membership function $\mu(x)$ defined over the interval $X = [0, 1]$. The function is characterized by a constant value of $\frac{1}{2}$ across most of the domain, with the exception of a small, symmetric triangular "hump" or local increase in membership value centered around a specific point $x^*$. This visualization is commonly used in fuzzy set theory to represent a "nearly indifferent" membership state with a slight preference or higher degree of membership near a specific value $x^*$.
</details>
Formally, we define a problem instance $\mathcal{I}(x^{*},\epsilon)$ by
$$
\displaystyle\mu(x)=\begin{cases}\nicefrac{{1}}{{2}},&\text{all arms $x$ with }|x-x^{*}|\geq\epsilon/L\\
\nicefrac{{1}}{{2}}+\epsilon-L\cdot|x-x^{*}|,&\text{otherwise}.\end{cases} \tag{54}
$$
It is easy to see that any such problem instance satisfies the Lipschitz Condition (50). We will refer to $\mu(·)$ as the bump function. We are ready to state the lower bound:
**Theorem 4.2**
*Let $\mathtt{ALG}$ be any algorithm for continuum-armed bandits with time horizon $T$ and Lipschitz constant $L$ . There exists a problem instance $\mathcal{I}=\mathcal{I}(x^{*},\epsilon)$ , for some $x^{*}â[0,1]$ and $\epsilon>0$ , such that
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}\left[\,R(T)\mid\mathcal{I}\,\right]\geq\Omega\left(\,L^{1/3}\cdot T^{2/3}\,\right). \tag{55}
$$*
For simplicity of exposition, assume the Lipschitz constant is $L=1$ ; arbitrary $L$ is treated similarly.
Fix $Kâ\mathbb{N}$ and partition arms into $K$ disjoint intervals of length $\tfrac{1}{K}$ . Use bump functions with $\epsilon=\tfrac{1}{2K}$ such that each interval either contains a bump or is completely flat. More formally, we use problem instances $\mathcal{I}(x^{*},\epsilon)$ indexed by $a^{*}â[K]:=\{1\,,\ ...\ ,K\}$ , where the best arm is $x^{*}=(2\epsilon-1)· a^{*}+\epsilon$ .
The intuition for the proof is as follows. We have these $K$ intervals defined above. Whenever an algorithm chooses an arm $x$ in one such interval, choosing the center of this interval is best: either this interval contains a bump and the center is the best arm, or all arms in this interval have the same mean reward $\nicefrac{{1}}{{2}}$ . But if we restrict to arms that are centers of the intervals, we have a family of problem instances of $K$ -armed bandits, where all arms have mean reward $\nicefrac{{1}}{{2}}$ except one with mean reward $\nicefrac{{1}}{{2}}+\epsilon$ . This is precisely the family of instances from $\mathtt{MainLB}$ . Therefore, one can apply the lower bound from $\mathtt{MainLB}$ , and tune the parameters to obtain (55). To turn this intuition into a proof, the main obstacle is to prove that choosing the center of an interval is really the best option. While this is a trivial statement for the immediate round, we need to argue carefullt that choosing an arm elsewhere would not be advantageous later on.
Let us recap $\mathtt{MainLB}$ in a way that is convenient for this proof. Recall that $\mathtt{MainLB}$ considered problem instances with 0-1 rewards such that all arms $a$ have mean reward $\nicefrac{{1}}{{2}}$ , except the best arm $a^{*}$ whose mean reward is $\nicefrac{{1}}{{2}}+\epsilon$ . Each instance is parameterized by best arm $a^{*}$ and $\epsilon>0$ , and denoted $\mathcal{J}(a^{*},\epsilon)$ .
**Theorem 4.3 (đŒđđđđ»đ±\mathtt{MainLB})**
*Consider stochastic bandits, with $K$ arms and time horizon $T$ (for any $K,T$ ). Let $\mathtt{ALG}$ be any algorithm for this problem. Pick any positive $\epsilonâ€\sqrt{cK/T}$ , where $c$ is an absolute constant from Lemma 2.8. Then there exists a problem instance $\mathcal{J}=\mathcal{J}(a^{*},\epsilon)$ , $a^{*}â[K]$ , such that
$$
\operatornamewithlimits{\mathbb{E}}\left[R(T)\mid\mathcal{J}\right]\geq\Omega(\epsilon T).
$$*
To prove Theorem 4.2, we show how to reduce the problem instances from $\mathtt{MainLB}$ to CAB in a way that we can apply $\mathtt{MainLB}$ and derive the claimed lower bound (55). On a high level, our plan is as follows: (i) take any problem instance $\mathcal{J}$ from $\mathtt{MainLB}$ and âembedâ it into CAB, and (ii) show that any algorithm for CAB will, in fact, need to solve $\mathcal{J}$ , (iii) tune the parameters to derive (55).
* Proof of Theorem4.2(L=1L=1)*
We use the problem instances $\mathcal{I}(x^{*},\epsilon)$ as described above. More precisely, we fix $Kâ\mathbb{N}$ , to be specified later, and let $\epsilon=\tfrac{1}{2K}$ . We index the instances by $a^{*}â[K]$ , so that
$$
x^{*}=f(a^{*}),\text{ where }f(a^{*}):=(2\epsilon-1)\cdot a^{*}+\epsilon.
$$ We use problem instances $\mathcal{J}(a^{*},\epsilon)$ from $\mathtt{MainLB}$ , with $K$ arms and the same time horizon $T$ . The set of arms in these instances is denoted $[K]$ . Each instance $\mathcal{J}=\mathcal{J}(a^{*},\epsilon)$ corresponds to an instance $\mathcal{I}=\mathcal{I}(x^{*},\epsilon)$ of CAB with $x^{*}=f(a^{*})$ . In particular, each arm $aâ[K]$ in $\mathcal{J}$ corresponds to an arm $x=f(a)$ in $\mathcal{I}$ . We view $\mathcal{J}$ as a discrete version of $\mathcal{I}$ . In particular, we have $\mu_{\mathcal{J}}(a)=\mu(f(a))$ , where $\mu(·)$ is the reward function for $\mathcal{I}$ , and $\mu_{\mathcal{J}}(·)$ is the reward function for $\mathcal{J}$ . Consider an execution of $\mathtt{ALG}$ on problem instance $\mathcal{I}$ of CAB, and use it to construct an algorithm $\mathtt{ALG}^{\prime}$ which solves an instance $\mathcal{J}$ of $K$ -armed bandits. Each round in algorithm $\mathtt{ALG}^{\prime}$ proceeds as follows. $\mathtt{ALG}$ is called and returns some arm $xâ[0,1]$ . This arm falls into the interval $\left[f(a)-\epsilon,\;f(a)+\epsilon\right)$ for some $aâ[K]$ . Then algorithm $\mathtt{ALG}^{\prime}$ chooses arm $a$ . When $\mathtt{ALG}^{\prime}$ receives reward $r$ , it uses $r$ and $x$ to compute reward $r_{x}â\{0,1\}$ such that $\operatornamewithlimits{\mathbb{E}}[r_{x}\mid x]=\mu(x)$ , and feed it back to $\mathtt{ALG}$ . We summarize this in a table:
| $\mathtt{ALG}$ for CAB instance $\mathcal{I}$ | $\mathtt{ALG}^{\prime}$ for $K$ -armed bandits instance $\mathcal{J}$ |
| --- | --- |
| chooses arm $xâ[0,1]$ | |
| chooses arm $aâ[K]$ with $xâ\left[f(a)-\epsilon,\;f(a)+\epsilon\right)$ | |
| receives reward $râ\{0,1\}$ with mean $\mu_{\mathcal{J}}(a)$ | |
| receives reward $r_{x}â\{0,1\}$ with mean $\mu(x)$ | | To complete the specification of $\mathtt{ALG}^{\prime}$ , it remains to define reward $r_{x}$ so that $\operatornamewithlimits{\mathbb{E}}[r_{x}\mid x]=\mu(x)$ , and $r_{x}$ can be computed using information available to $\mathtt{ALG}^{\prime}$ in a given round. In particular, the computation of $r_{x}$ cannot use $\mu_{\mathcal{J}}(a)$ or $\mu(x)$ , since they are not know to $\mathtt{ALG}^{\prime}$ . We define $r_{x}$ as follows:
$$
\displaystyle r_{x}=\begin{cases}r&\text{with probability $p_{x}\in[0,1]$}\\
X&\text{otherwise},\end{cases} \tag{56}
$$
where $X$ is an independent toss of a Bernoulli random variable with expectation $\nicefrac{{1}}{{2}}$ , and probability $p_{x}$ is to be specified later. Then
| | $\displaystyle\operatornamewithlimits{\mathbb{E}}[r_{x}\mid x]$ | $\displaystyle=p_{x}·\mu_{\mathcal{J}}(a)+(1-p_{x})·\nicefrac{{1}}{{2}}$ | |
| --- | --- | --- | --- |
if we set $p_{x}=1-\left|x-f(a)\right|/\epsilon$ so as to match the definition of $\mathcal{I}(x^{*},\epsilon)$ in Eq. (54). For each round $t$ , let $x_{t}$ and $a_{t}$ be the arms chosen by $\mathtt{ALG}$ and $\mathtt{ALG}^{\prime}$ , resp. Since $\mu_{\mathcal{J}}(a_{t})â„\nicefrac{{1}}{{2}}$ , we have
$$
\mu(x_{t})\leq\mu_{\mathcal{J}}(a_{t}).
$$
It follows that the total expected reward of $\mathtt{ALG}$ on instance $\mathcal{I}$ cannot exceed that of $\mathtt{ALG}^{\prime}$ on instance $\mathcal{J}$ . Since the best arms in both problem instances have the same expected rewards $\nicefrac{{1}}{{2}}+\epsilon$ , it follows that
$$
\operatornamewithlimits{\mathbb{E}}[R(T)\mid\mathcal{I}]\geq\operatornamewithlimits{\mathbb{E}}[R^{\prime}(T)\mid\mathcal{J}],
$$
where $R(T)$ and $R^{\prime}(T)$ denote regret of $\mathtt{ALG}$ and $\mathtt{ALG}^{\prime}$ , respectively. Recall that algorithm $\mathtt{ALG}^{\prime}$ can solve any $K$ -armed bandits instance of the form $\mathcal{J}=\mathcal{J}(a^{*},\epsilon)$ . Let us apply Theorem 4.3 to derive a lower bound on the regret of $\mathtt{ALG}^{\prime}$ . Specifically, let us fix $K=(T/4c)^{1/3}$ , so as to ensure that $\epsilonâ€\sqrt{cK/T}$ , as required in Theorem 4.3. Then for some instance $\mathcal{J}=\mathcal{J}(a^{*},\epsilon)$ ,
$$
\operatornamewithlimits{\mathbb{E}}[R^{\prime}(T)\mid\mathcal{J}]\geq\Omega(\sqrt{\epsilon T})=\Omega(T^{2/3})
$$
Thus, taking the corresponding instance $\mathcal{I}$ of CAB, we conclude that $\operatornamewithlimits{\mathbb{E}}[R(T)\mid\mathcal{I}]â„\Omega(T^{2/3})$ . â
21 Lipschitz bandits
A useful interpretation of continuum-armed bandits is that arms lie in a known metric space $(X,\mathcal{D})$ , where $X=[0,1]$ is a ground set and $\mathcal{D}(x,y)=L·|x-y|$ is the metric. In this section we extend this problem and the uniform discretization approach to arbitrary metric spaces.
The general problem, called Lipschitz bandits Problem, is a stochastic bandit problem such that the expected rewards $\mu(·)$ satisfy the Lipschitz condition relative to some known metric $\mathcal{D}$ on the set $X$ of arms:
$$
\displaystyle|\mu(x)-\mu(y)|\leq\mathcal{D}(x,y)\quad\text{for any two arms $x,y$}. \tag{57}
$$
The metric space $(X,\mathcal{D})$ can be arbitrary, as far as this problem formulation is concerned (see Section 21.1). It represents an abstract notion of known similarity between arms. Note that w.l.o.g. $\mathcal{D}(x,y)†1$ . The set of arms $X$ can be finite or infinite, this distinction is irrelevant to the essence of the problem. While some of the subsequent definitions are more intuitive for infinite $X$ , we state them so that they are meaningful for finite $X$ , too. A problem instance is specified by the metric space $(X,\mathcal{D})$ , reward distributions, and the time horizon $T$ ; for reward distributions, we are mainly interested in mean rewards $\mu(·)$ .
That $\mathcal{D}$ is a metric is without loss of generality, in the following sense. Suppose the algorithm is given constraints $|\mu(x)-\mu(y)|â€\mathcal{D}_{0}(x,y)$ for all arms $xâ y$ and some numbers $\mathcal{D}_{0}(x,y)â(0,1]$ . Then one could define $\mathcal{D}$ as the shortest-paths closure of $\mathcal{D}_{0}$ , i.e., $\mathcal{D}(x,y)=\min\sum_{i}\mathcal{D}_{0}(x_{i},x_{i+1})$ , where the $\min$ is over all finite sequences of arms $\sigma=(x_{1}\,,\ ...\ ,x_{n_{\sigma}})$ which start with $x$ and end with $y$ .
21.1 Brief background on metric spaces
A metric space is a pair $(X,\mathcal{D})$ , where $X$ is a set (called the ground set) and $\mathcal{D}$ is a metric on $X$ , i.e., a function $\mathcal{D}:XĂ Xâ\mathbb{R}$ which satisfies the following axioms:
| | $\displaystyle\mathcal{D}(x,y)$ | $\displaystyleâ„ 0$ | $\displaystyle\text{\emph{(non-negativity)}},$ | |
| --- | --- | --- | --- | --- |
Intuitively, the metric represents âdistanceâ between the elements of $X$ . For $Yâ X$ , the pair $(Y,\mathcal{D})$ is also a metric space, where, by a slight abuse of notation, $\mathcal{D}$ denotes the same metric restricted $Y$ . The diameter of $Y$ is the maximal distance between any two points in $Y$ , i.e., $\sup_{x,yâ Y}\mathcal{D}(x,y)$ . A metric space $(X,\mathcal{D})$ is called finite (resp., infinite) if so is $X$ .
Some notable examples:
- $X=[0,1]^{d}$ , $dâ\mathbb{N}$ and the metric is the $p$ -norm, $pâ„ 1$ :
$$
\textstyle\ell_{p}(x,y)=\|x-y\|_{p}:=\left(\,\sum_{i=1}^{d}(x_{i}-y_{i})^{p}\,\right)^{1/p}.
$$
Most commonly are $\ell_{1}$ -metric (a.k.a. Manhattan metric) and $\ell_{2}$ -metric (a.k.a. Euclidean distance).
- $X=[0,1]$ and the metric is $\mathcal{D}(x,y)=|x-y|^{1/d}$ , $dâ„ 1$ . In a more succinct notation, this metric space is denoted $\left([0,1],\,\ell_{2}^{1/d}\right)$ .
- $X$ is the set of nodes of a graph, and $\mathcal{D}$ is the shortest-path metric: $\mathcal{D}(x,y)$ is the length of a shortest path between nodes $x$ and $y$ .
- $X$ is the set of leaves in a rooted tree, where each internal node $u$ is assigned a weight $w(u)>0$ . The tree distance between two leaves $x$ and $y$ is $w(u)$ , where $u$ is the least common ancestor of $x$ and $y$ . (Put differently, $u$ is the root of the smallest subtree containing both $x$ and $y$ .) In particular, exponential tree distance assigns weight $c^{h}$ to each node at depth $h$ , for some constant $câ(0,1)$ .
21.2 Uniform discretization
We generalize uniform discretization to arbitrary metric spaces as follows. We take an algorithm $\mathtt{ALG}$ satisfying (52), as in Section 20.1, and we run it on a fixed subset of arms $Sâ X$ .
**Definition 4.4**
*A subset $Sâ X$ is called an $\epsilon$ -mesh, $\epsilon>0$ , if every point $xâ X$ is within distance $\epsilon$ from $S$ , in the sense that $\mathcal{D}(x,y)â€\epsilon$ for some $yâ S$ .*
It is easy to see that the discretization error of an $\epsilon$ -mesh is $\mathtt{DE}(S)â€\epsilon$ . The developments in Section 20.1 carry over word-by-word, up until Eq. (53). We summarize these developments as follows.
**Theorem 4.5**
*Consider Lipschitz bandits with time horizon $T$ . Optimizing over the choice of an $\epsilon$ -mesh, uniform discretization with algorithm $\mathtt{ALG}$ satisfying (52) attains regret
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}[R(T)]\leq\inf_{\epsilon>0,\;\text{$\epsilon$-mesh $S$}}\;\epsilon T+c_{\mathtt{ALG}}\cdot\sqrt{|S|\,T\log T}. \tag{58}
$$*
**Remark 4.6**
*How do we construct a good $\epsilon$ -mesh? For many examples the construction is trivial, e.g., a uniform discretization in continuum-armed bandits or in the next example. For an arbitrary metric space and a given $\epsilon>0$ , a standard construction starts with an empty set $S$ , adds any arm that is within distance $>\epsilon$ from all arms in $S$ , and stops when such arm does not exist. Now, consider different values of $\epsilon$ in exponentially decreasing order: $\epsilon=2^{-i}$ , $i=1,2,3,\,...$ . For each such $\epsilon$ , compute an $\epsilon$ -mesh $S_{\epsilon}$ as specified above, and stop at the largest $\epsilon$ such that $\epsilon T℠c_{\mathtt{ALG}}·\sqrt{|S_{\epsilon}|\,T\log T}$ . This $\epsilon$ -mesh optimizes the right-hand side in (58) up to a constant factor, see Exercise 4.1*
**Example 4.7**
*To characterize the regret of uniform discretization more compactly, suppose the metric space is $X=[0,1]^{d}$ , $dâ\mathbb{N}$ under the $\ell_{p}$ metric, $pâ„ 1$ . Consider a subset $Sâ X$ that consists of all points whose coordinates are multiples of a given $\epsilon>0$ . Then $|S|â€{\lceil{1/\epsilon}\rceil}^{d}$ points, and its discretization error is $\mathtt{DE}(S)†c_{p,d}·\epsilon$ , where $c_{p,d}$ is a constant that depends only on $p$ and $d$ ; e.g., $c_{p,d}=d$ for $p=1$ . Plugging this into (53) and taking $\epsilon=(T\,/\,\log T)^{-1/(d+2)}$ , we obtain
| | $\displaystyle\operatornamewithlimits{\mathbb{E}}[R(T)]â€(1+c_{\mathtt{ALG}})· T^{(d+1)/(d+2)}\;(c\log T)^{1/(d+2)}.$ | |
| --- | --- | --- |*
The $\tilde{O}(T^{(d+1)/(d+2)})$ regret rate in Example 4.7 extends to arbitrary metric spaces via the notion of covering dimension. In essence, it is the smallest $d$ such that each $\epsilon>0$ admits an $\epsilon$ -mesh of size $O(\epsilon^{-d})$ .
**Definition 4.8**
*Fix a metric space $(X,\mathcal{D})$ . An $\epsilon$ -covering, $\epsilon>0$ is a collection of subsets $X_{i}â X$ such that the diameter of each subset is at most $\epsilon$ and $X=\bigcup X_{i}$ . The smallest number of subsets in an $\epsilon$ -covering is called the covering number and denoted $N_{\epsilon}(X)$ . The covering dimension, with multiplier $c>0$ , is
$$
\displaystyle\mathtt{COV}_{c}(X)=\inf_{d\geq 0}\left\{\,N_{\epsilon}(X)\leq c\cdot\epsilon^{-d}\quad\forall\epsilon>0\,\right\}. \tag{59}
$$*
**Remark 4.9**
*Any $\epsilon$ -covering gives rise to an $\epsilon$ -mesh: indeed, just pick one arbitrary representative from each subset in the covering. Thus, there exists an $\epsilon$ -mesh $S$ with $|S|=N_{\epsilon}(X)$ . We define the covering numbers in terms of $\epsilon$ -coverings (rather than more directly in terms of $\epsilon$ -meshes) in order to ensure that $N_{\epsilon}(Y)†N_{\epsilon}(X)$ for any subset $Yâ X$ , and consequently $\mathtt{COV}_{c}(Y)â€\mathtt{COV}_{c}(X)$ . In words, covering numbers characterize complexity of a metric space, and a subset $Yâ X$ cannot be more complex than $X$ .*
In particular, the covering dimension in Example 4.7 is $d$ , with a large enough multiplier $c$ . Likewise, the covering dimension of $\left([0,1],\,\ell_{2}^{1/d}\right)$ is $d$ , for any $dâ„ 1$ ; note that it can be fractional.
**Remark 4.10**
*Covering dimension is often stated without the multiplier: $\mathtt{COV}(X)=âf_{c>0}\mathtt{COV}_{c}(X)$ . This version is meaningful (and sometimes more convenient) for infinite metric spaces. However, for finite metric spaces it is trivially $0$ , so we need to fix the multiplier for a meaningful definition. Furthermore, our definition allows for more precise regret bounds, both for finite and infinite metric spaces.*
To de-mystify the infimum in Eq. (59), let us state a corollary: if $d=\mathtt{COV}_{c}(X)$ then
$$
\displaystyle N_{\epsilon}(X)\leq c^{\prime}\cdot\epsilon^{-d}\qquad\forall c^{\prime}>c,\,\epsilon>0. \tag{60}
$$
Thus, we take an $\epsilon$ -mesh $S$ of size $|S|=N_{\epsilon}(X)†O(c/\epsilon^{d})$ . Taking $\epsilon=(T\,/\,\log T)^{-1/(d+2)}$ , like in Example 4.7, and plugging this into into Eq. (53), we obtain the following theorem:
**Theorem 4.11**
*Consider Lipschitz bandits on a metric space $(X,\mathcal{D})$ , with time horizon $T$ . Let $\mathtt{ALG}$ be any algorithm satisfying (52). Fix any $c>0$ , and let $d=\mathtt{COV}_{c}(X)$ be the covering dimension. Then there exists a subset $Sâ X$ such that running $\mathtt{ALG}$ on the set of arms $S$ yields regret
| | $\displaystyle\operatornamewithlimits{\mathbb{E}}[R(T)]â€(1+c_{\mathtt{ALG}})· T^{(d+1)/(d+2)}·(c\,\log T)^{1/(d+2)}.$ | |
| --- | --- | --- |
Specifically, $S$ can be any $\epsilon$ -mesh of size $|S|†O(c/\epsilon^{d})$ , where $\epsilon=(T\,/\,\log T)^{-1/(d+2)}$ ; such $S$ exists.*
The upper bounds in Theorem 4.5 and Theorem 4.11 are the best possible in the worst case, up to $O(\log T)$ factors. The lower bounds follow from the same proof technique as Theorem 4.2, see the exercises in Section 24.2 for precise formulations and hints. A representative example is as follows:
**Theorem 4.12**
*Consider Lipschitz bandits on metric space $\left([0,1],\,\ell_{2}^{1/d}\right)$ , for any $dâ„ 1$ , with time horizon $T$ . For any algorithm, there exists a problem instance exists a problem instance $\mathcal{I}$ such that
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}\left[\,R(T)\mid\mathcal{I}\,\right]\geq\Omega\left(\,T^{(d+1)/(d+2)}\,\right). \tag{61}
$$*
22 Adaptive discretization: the Zooming Algorithm
Despite the existence of a matching lower bound, the fixed discretization approach is wasteful. Observe that the discretization error of $S$ is at most the minimal distance between $S$ and the best arm $x^{*}$ :
$$
\mathtt{DE}(S)\leq\mathcal{D}(S,x^{*}):=\min_{x\in S}\mathcal{D}(x,x^{*}).
$$
So it should help to decrease $|S|$ while keeping $\mathcal{D}(S,x^{*})$ constant. Thinking of arms in $S$ as âprobesâ that the algorithm places in the metric space. If we know that $x^{*}$ lies in a particular âregionâ of the metric space, then we do not need to place probes in other regions. Unfortunately, we do not know in advance where $x^{*}$ is, so we cannot optimize $S$ this way if $S$ needs to be chosen in advance.
However, an algorithm could approximately learn the mean rewards over time, and adjust the placement of the probes accordingly, making sure that one has more probes in more âpromisingâ regions of the metric space. This approach is called adaptive discretization. Below we describe one implementation of this approach, called the zooming algorithm. On a very high level, the idea is that we place more probes in regions that could produce better rewards, as far as the algorithm knowns, and less probes in regions which are known to yield only low rewards with high confidence. What can we hope to prove for this algorithm, given the existence of a matching lower bound for fixed discretization? The goal here is to attain the same worst-case regret as in Theorem 4.11, but do âbetterâ on âniceâ problem instances. Quantifying what we mean by âbetterâ and âniceâ here is an important aspect of the overall research challenge.
The zooming algorithm will bring together three techniques: the âUCB techniqueâ from algorithm $\mathtt{UCB1}$ , the new technique of âadaptive discretizationâ, and the âclean eventâ technique in the analysis.
22.1 Algorithm
The algorithm maintains a set $Sâ X$ of âactive armsâ. In each round, some arms may be âactivatedâ according to the âactivation ruleâ, and one active arm is selected to according to the âselection ruleâ. Once an arm is activated, it cannot be âdeactivatedâ. This is the whole algorithm: we just need to specify the activation rule and the selection rule.
Confidence radius/ball. Fix round $t$ and an arm $x$ that is active at this round. Let $n_{t}(x)$ is the number of rounds before round $t$ when this arm is chosen, and let $\mu_{t}(x)$ be the average reward in these rounds. The confidence radius of arm $x$ at time $t$ is defined as
$$
r_{t}(x)=\sqrt{\frac{2\log T}{n_{t}(x)+1}}.
$$
Recall that this is essentially the smallest number so as to guarantee with high probability that
$$
|\mu(x)-\mu_{t}(x)|\leq r_{t}(x).
$$
The confidence ball of arm $x$ is a closed ball in the metric space with center $x$ and radius $r_{t}(x)$ .
$$
\mathbf{B}_{t}(x)=\{y\in X:\;\mathcal{D}(x,y)\leq r_{t}(x)\}.
$$
Activation rule. We start with some intuition. We will estimate the mean reward $\mu(x)$ of a given active arm $x$ using only the samples from this arm. While samples from ânearbyâ arms could potentially improve the estimates, this choice simplifies the algorithm and the analysis, and does not appear to worsen the regret bounds. Suppose arm $y$ is not active in round $t$ , and lies very close to some active arm $x$ , in the sense that $\mathcal{D}(x,y)\ll r_{t}(x)$ . Then the algorithm does not have enough samples of $x$ to distinguish $x$ and $y$ . Thus, instead of choosing arm $y$ the algorithm might as well choose arm $x$ . We conclude there is no real need to activate $y$ yet. Going further with this intuition, there is no real need to activate any arm that is covered by the confidence ball of any active arm. We would like to maintain the following invariant:
As the algorithm plays some arms over time, their confidence radii and the confidence balls get smaller, and some arm $y$ may become uncovered. Then we simply activate it! Since immediately after activation the confidence ball of $y$ includes the entire metric space, we see that the invariant is preserved.
Thus, the activation rule is very simple:
| | If some arm $y$ becomes uncovered by confidence balls of the active arms, activate $y$ . | |
| --- | --- | --- |
With this activation rule, the zooming algorithm has the following âself-adjusting propertyâ. The algorithm âzooms inâ on a given region $R$ of the metric space (i.e., activates many arms in $R$ ) if and only if the arms in $R$ are played often. The latter happens (under any reasonable selection rule) if and only if the arms in $R$ have high mean rewards.
Selection rule. We extend the technique from algorithm $\mathtt{UCB1}$ . If arm $x$ is active at time $t$ , we define
$$
\displaystyle\mathtt{index}_{t}(x)=\bar{\mu_{t}}(x)+2r_{t}(x) \tag{63}
$$
The selection rule is very simple:
| | Play an active arm with the largest index (break ties arbitrarily). | |
| --- | --- | --- |
Recall that algorithm $\mathtt{UCB1}$ chooses an arm with largest upper confidence bound (UCB) on the mean reward, defined as $\mathtt{UCB}_{t}(x)=\mu_{t}(x)+r_{t}(x)$ . So $\mathtt{index}_{t}(x)$ is very similar, and shares the intuition behind $\mathtt{UCB1}$ : if $\mathtt{index}_{t}(x)$ is large, then either $\mu_{t}(x)$ is large, and so $x$ is likely to be a good arm, or $r_{t}(x)$ is large, so arm $x$ has not been played very often, and should probably be explored more. And the â+â in (63) is a way to trade off exploration and exploitation. What is new here, compared to $\mathtt{UCB1}$ , is that $\mathtt{index}_{t}(x)$ is a UCB not only on the mean reward of $x$ , but also on the mean reward of any arm in the confidence ball of $x$ .
To summarize, the algorithm is as follows:
Initialize: set of active arms $Sâ\emptyset$ .
for each round $t=1,2,...$ do
// activation rule
if some arm $y$ is not covered by the confidence balls of active arms then
pick any such arm $y$ and âactivateâ it: $Sâ S\cap\{y\}$ .
// selection rule
Play an active arm $x$ with the largest $\mathtt{index}_{t}(x)$ .
end for
Algorithm 1 Zooming algorithm for adaptive discretization.
22.2 Analysis: clean event
We define a âclean eventâ $\mathcal{E}$ much like we did in Chapter 1, and prove that it holds with high probability. The proof is more delicate than in Chapter 1, essentially because we cannot immediately take the Union Bound over all of $X$ . The rest of the analysis would simply assume that this event holds.
We consider a $KĂ T$ table of realized rewards, with $T$ columns and a row for each arm $x$ . The $j$ -th column for arm $x$ is the reward for the $j$ -th time this arm is chosen by the algorithm. We assume, without loss of generality, that this entire table is chosen before round 1: each cell for a given arm is an independent draw from the reward distribution of this arm. The clean event is defined as a property of this reward table. For each arm $x$ , the clean event is
$$
\mathcal{E}_{x}=\left\{\;|\mu_{t}(x)-\mu(x)|\leq r_{t}(x)\quad\text{for all rounds $t\in[T+1]$}\;\right\}.
$$
Here $[T]:=\{1,2\,,\ ...\ ,T\}$ . For convenience, we define $\mu_{t}(x)=0$ if arm $x$ has not yet been played by the algorithm, so that in this case the clean event holds trivially. We are interested in the event $\mathcal{E}=\cap_{xâ X}\mathcal{E}_{x}$ .
To simplify the proof of the next claim, we assume that realized rewards take values on a finite set.
**Claim 4.13**
*Assume that realized rewards take values on a finite set. Then $\Pr[\mathcal{E}]â„ 1-\frac{1}{T^{2}}$ .*
* Proof*
By Hoeffding Inequality, $\Pr[\mathcal{E}_{x}]â„ 1-\frac{1}{T^{4}}$ for each arm $xâ X$ . However, one cannot immediately apply the Union Bound here because there may be too many arms. Fix an instance of Lipschitz bandits. Let $X_{0}$ be the set of all arms that can possibly be activated by the algorithm on this problem instance. Note that $X_{0}$ is finite; this is because the algorithm is deterministic, the time horizon $T$ is fixed, and, as we assumed upfront, realized rewards can take only finitely many values. (This is the only place where we use this assumption.) Let $N$ be the total number of arms activated by the algorithm. Define arms $y_{j}â X_{0}$ , $jâ[T]$ , as follows
$$
y_{j}=\left\{\begin{array}[]{ll}j\text{-th arm activated,}&\text{\quad if }j\leq N\\
y_{N},&\text{\quad otherwise}.\end{array}\right.
$$
Here $N$ and $y_{j}$ âs are random variables, the randomness coming from the reward realizations. Note that $\{y_{1}\,,\ ...\ ,y_{T}\}$ is precisely the set of arms activated in a given execution of the algorithm. Since the clean event holds trivially for all arms that are not activated, the clean event can be rewritten as $\mathcal{E}=\cap_{j=1}^{T}\mathcal{E}_{y_{j}}.$ In what follows, we prove that the clean event $\mathcal{E}_{y_{j}}$ happens with high probability for each $jâ[T]$ . Fix an arm $xâ X_{0}$ and fix $jâ[T]$ . Whether the event $\{y_{j}=x\}$ holds is determined by the rewards of other arms. (Indeed, by the time arm $x$ is selected by the algorithm, it is already determined whether $x$ is the $j$ -th arm activated!) Whereas whether the clean event $\mathcal{E}_{x}$ holds is determined by the rewards of arm $x$ alone. It follows that the events $\{y_{j}=x\}$ and $\mathcal{E}_{x}$ are independent. Therefore, if $\Pr[y_{j}=x]>0$ then
$$
\Pr[\mathcal{E}_{y_{j}}\mid y_{j}=x]=\Pr[\mathcal{E}_{x}\mid y_{j}=x]=\Pr[\mathcal{E}_{x}]\geq 1-\tfrac{1}{T^{4}}
$$
Now we can sum over all $xâ X_{0}$ :
$$
\Pr[\mathcal{E}_{y_{j}}]=\sum_{x\in X_{0}}\Pr[y_{j}=x]\cdot\Pr[\mathcal{E}_{y_{j}}\mid x=y_{j}]\geq 1-\tfrac{1}{T^{4}}
$$ To complete the proof, we apply the Union bound over all $jâ[T]$ :
$$
\Pr[\mathcal{E}_{y_{j}},j\in[T]]\geq 1-\tfrac{1}{T^{3}}.\qed
$$
We assume the clean event $\mathcal{E}$ from here on.
22.3 Analysis: bad arms
Let us analyze the âbad armsâ: arms with low mean rewards. We establish two crucial properties: that active bad arms must be far apart in the metric space (Corollary 4.15), and that each âbadâ arm cannot be played too often (Corollary 4.16). As usual, let $\mu^{*}=\sup_{xâ X}\mu(x)$ be the best reward, and let $\Delta(x)=\mu^{*}-\mu(x)$ denote the âgapâ of arm $x$ . Let $n(x)=n_{T+1}(x)$ be the total number of samples from arm $x$ .
The following lemma encapsulates a crucial argument which connects the best arm and the arm played in a given round. In particular, we use the main trick from the analysis of $\mathtt{UCB1}$ and the Lipschitz property.
**Lemma 4.14**
*$\Delta(x)†3\,r_{t}(x)$ for each arm $x$ and each round $t$ .*
* Proof*
Suppose arm $x$ is played in this round. By the covering invariant, the best arm $x^{*}$ was covered by the confidence ball of some active arm $y$ , i.e., $x^{*}â\mathbf{B}_{t}(y)$ . It follows that
$$
\mathtt{index}(x)\geq\mathtt{index}(y)=\underbrace{\mu_{t}(y)+r_{t}(y)}_{\geq\mu(y)}+r_{t}(y)\geq\mu(x^{*})=\mu^{*}
$$
The last inequality holds because of the Lipschitz condition. On the other hand:
$$
\mathtt{index}(x)=\underbrace{\mu_{t}(x)}_{\leq\mu(x)+r_{t}(x)}+2\cdot r_{t}(x)\leq\mu(x)+3\cdot r_{t}(x)
$$
Putting these two equations together: $\Delta(x):=\mu^{*}-\mu(x)†3· r_{t}(x)$ . Now suppose arm $x$ is not played in round $t$ . If it has never been played before round $t$ , then $r_{t}(x)>1$ and the lemma follows trivially. Else, letting $s$ be the last time when $x$ has been played before round $t$ , we see that $r_{t}(x)=r_{s}(x)â„\Delta(x)/3$ . â
**Corollary 4.15**
*For any two active arms $x,y$ , we have $\mathcal{D}(x,y)>\tfrac{1}{3}\;\min\left(\Delta(x),\;\Delta(y)\right)$ .*
* Proof*
W.l.o.g. assume that $x$ has been activated before $y$ . Let $s$ be the time when $y$ has been activated. Then $\mathcal{D}(x,y)>r_{s}(x)$ by the activation rule. And $r_{s}(x)â„\Delta(x)/3$ by Lemma 4.14. â
**Corollary 4.16**
*For each arm $x$ , we have $n(x)†O(\log T)\;\Delta^{-2}(x)$ .*
* Proof*
Use Lemma 4.14 for $t=T$ , and plug in the definition of the confidence radius. â
22.4 Analysis: covering numbers and regret
For $r>0$ , consider the set of arms whose gap is between $r$ and $2r$ :
$$
X_{r}=\{x\in X:r\leq\Delta(x)<2r\}.
$$
Fix $iâ\mathbb{N}$ and let $Y_{i}=X_{r}$ , where $r=2^{-i}$ . By Corollary 4.15, for any two arms $x,yâ Y_{i}$ , we have $\mathcal{D}(x,y)>r/3$ . If we cover $Y_{i}$ with subsets of diameter $r/3$ , then arms $x$ and $y$ cannot lie in the same subset. Since one can cover $Y_{i}$ with $N_{r/3}(Y_{i})$ such subsets, it follows that $|Y_{i}|†N_{r/3}(Y_{i})$ .
Using Corollary 4.16, we have:
| | $\displaystyle R_{i}(T):=\sum_{xâ Y_{i}}\Delta(x)· n_{t}(x)â€\frac{O(\log T)}{\Delta(x)}· N_{r/3}(Y_{i})â€\frac{O(\log T)}{r}· N_{r/3}(Y_{i}).$ | |
| --- | --- | --- |
Pick $\delta>0$ , and consider arms with $\Delta(·)â€\delta$ separately from those with $\Delta(·)>\delta$ . Note that the total regret from the former cannot exceed $\delta$ per round. Therefore:
$$
\displaystyle R(T) \displaystyle\leq\delta T+\sum_{i:\;r=2^{-i}>\delta}R_{i}(T) \displaystyle\leq\delta T+\sum_{i:\;r=2^{-i}>\delta}\frac{\Theta(\log T)}{r}\;N_{r/3}(Y_{i}) \displaystyle\leq\delta T+O(c\cdot\log T)\cdot(\tfrac{1}{\delta})^{d+1} \tag{64}
$$
where $c$ is a constant and $d$ is some number such that
$$
N_{r/3}(X_{r})\leq c\cdot r^{-d}\quad\forall r>0.
$$
The smallest such $d$ is called the zooming dimension:
**Definition 4.17**
*For an instance of Lipschitz MAB, the zooming dimension with multiplier $c>0$ is
$$
\inf_{d\geq 0}\left\{N_{r/3}(X)\leq c\cdot r^{-d}\quad\forall r>0\right\}.
$$*
Choosing $\delta=(\frac{\log T}{T})^{1/(d+2)}$ in (65), we obtain $R(T)†O\left(\,T^{(d+1)/(d+2)}\;(c\log T)^{1/(d+2)}\,\right)$ . Note that we make this chose in the analysis only; the algorithm does not depend on the $\delta$ .
**Theorem 4.18**
*Consider Lipschitz bandits with time horizon $T$ . Assume that realized rewards take values on a finite set. For any given problem instance and any $c>0$ , the zooming algorithm attains regret
| | $\displaystyle\operatornamewithlimits{\mathbb{E}}[R(T)]†O\left(\,T^{(d+1)/(d+2)}\;(c\log T)^{1/(d+2)}\,\right),$ | |
| --- | --- | --- |
where $d$ is the zooming dimension with multiplier $c$ .*
While the covering dimension is a property of the metric space, the zooming dimension is a property of the problem instance: it depends not only on the metric space, but on the mean rewards. In general, the zooming dimension is at most as large as the covering dimension, but may be much smaller (see Exercises 4.5 and 4.6). This is because in the definition of the covering dimension one needs to cover all of $X$ , whereas in the definition of the zooming dimension one only needs to cover set $X_{r}$
While the regret bound in Theorem 4.18 is appealingly simple, a more precise regret bound is given in (64). Since the algorithm does not depend on $\delta$ , this bound holds for all $\delta>0$ .
23 Literature review and discussion
Continuum-armed bandits have been introduced in Agrawal (1995), and further studied in (Kleinberg, 2004; Auer et al., 2007). Uniform discretization has been introduced in Kleinberg and Leighton (2003) for dynamic pricing, and in Kleinberg (2004) for continuum-armed bandits; Kleinberg et al. (2008b) observed that it easily extends to Lipschitz bandits. While doomed to $\tilde{O}(T^{2/3})$ regret in the worst case, uniform discretization yields $\tilde{O}(\sqrt{T})$ regret under strong concavity Kleinberg and Leighton (2003); Auer et al. (2007).
Lipschitz bandits have been introduced in Kleinberg et al. (2008b) and in a near-simultaneous and independent paper (Bubeck et al., 2011b). The zooming algorithm is from Kleinberg et al. (2008b), see Kleinberg et al. (2019) for a definitive journal version. Bubeck et al. (2011b) present a similar but technically different algorithm, with similar regret bounds.
Lower bounds for uniform discretization trace back to Kleinberg (2004), who introduces the proof technique in Section 20.2 and obtains Theorem 4.12. The other lower bounds follow easily from the same technique. The explicit dependence on $L$ in Theorem 4.2 first appeared in Bubeck et al. (2011c), and the formulation in Exercise 4.4 (b) is from Bubeck et al. (2011b). Our presentation in Section 20.2 roughly follows that in Slivkins (2014) and (Bubeck et al., 2011b).
A line of work that pre-dated and inspired Lipschitz bandits posits that the algorithm is given a âtaxonomyâ on arms: a tree whose leaves are arms, where arms in the same subtree being âsimilarâ to one another (Kocsis and Szepesvari, 2006; Pandey et al., 2007a; Munos and Coquelin, 2007). Numerical similarity information is not revealed. While these papers report successful empirical performance of their algorithms on some examples, they do not lead to non-trivial regret bounds. Essentially, regret scales as the number of arms in the worst case, whereas in Lipschitz bandits regret is bounded in terms of covering numbers.
Covering dimension is closely related to several other âdimensionsâ, such as Haussdorff dimension, capacity dimension, box-counting dimension, and Minkowski-Bouligand Dimension, that characterize the covering properties of a metric space in fractal geometry (e.g., see Schroeder, 1991). Covering numbers and covering dimension have been widely used in machine learning to characterize the complexity of the hypothesis space in classification problems; however, we are not aware of a clear technical connection between this usage and ours. Similar but stronger notions of âdimensionâ of a metric space have been studied in theoretical computer science: the ball-growth dimension (e.g., Karger and Ruhl, 2002; Abraham and Malkhi, 2005; Slivkins, 2007) and the doubling dimension (e.g., Gupta et al., 2003; Talwar, 2004; Kleinberg et al., 2009a). A metric has ball-growth dimension $d$ if doubling the radius of a ball increases the number of points by at most $O(2^{d})$ . A metric has doubling dimension $d$ if any ball can be covered with at most $O(2^{d})$ balls of half the radius. These notions allow for (more) efficient algorithms in many different problems: space-efficient distance representations such as metric embeddings, distance labels, and sparse spanners; network primitives such as routing schemes and distributed hash tables; approximation algorithms for optimization problems such as traveling salesman, $k$ -median, and facility location.
23.1 Further results on Lipschitz bandits
Zooming algorithm. The analysis of the zooming algorithm, both in Kleinberg et al. (2008b, 2019) and in this chapter, goes through without some of the assumptions. First, there is no need to assume that the metric satisfies triangle inequality (although this assumption is useful for the intuition). Second, Lipschitz condition (57) only needs to hold for pairs $(x,y)$ such that $x$ is the best arm. A similar algorithm in Bubeck et al. (2011b) only requires the Lipschitz condition when both arms are near the best arm. Third, no need to restrict realized rewards to finitely many possible values (but one needs a slightly more careful analysis of the clean event). Fourth, no need for a fixed time horizon: The zooming algorithm can achieve the same regret bound for all rounds at once, by an easy application of the âdoubling trickâ from Section 5.
The zooming algorithm attains improved regret bounds for several special cases (Kleinberg et al., 2008b). First, if the maximal payoff is near $1$ . Second, when $\mu(x)=1-f(\mathcal{D}(x,S))$ , where $S$ is a âtarget setâ that is not revealed to the algorithm. Third, if the realized reward from playing each arm $x$ is $\mu(x)$ plus an independent noise, for several noise distributions; in particular, if rewards are deterministic.
The zooming algorithm achieves near-optimal regret bounds, in a very strong sense (Slivkins, 2014). The ârawâ upper bound in (64) is optimal up to logarithmic factors, for any algorithm, any metric space, and any given value of this upper bound. Consequently, the upper bound in Theorem 4.18 is optimal, up to logarithmic factors, for any algorithm and any given value $d$ of the zooming dimension that does not exceed the covering dimension. This holds for various metric spaces, e.g., $\left([0,1],\,\ell_{2}^{1/d}\right)$ and $\left([0,1]^{d},\,\ell_{2}\right)$ .
The zooming algorithm, with similar upper and lower bounds, can be extended to the âcontextualâ version of Lipschitz bandits (Slivkins, 2014), see Sections 42 and 47 for details and discussion.
| $c_{\mathcal{I}}$ $f_{\mathcal{I}}(t)$ | worst-case | instance-dependent |
| --- | --- | --- |
| worst-case | e.g., $f(t)=\tilde{O}(t^{2/3})$ for CAB | e.g., zooming dimension |
| instance-dependent | e.g., $f(t)=\log(t)$ for $K<â$ arms; see Table 2 for $K=â$ arms | â |
Table 1: Worst-case vs. instance-dependent regret rates of the form (66).
Worst-case vs. instance-dependent regret bounds. This distinction is more subtle than in stochastic bandits. Generically, we have regret bounds of the form
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}\left[\,R(t)\mid\mathcal{I}\,\right]\leq c_{\mathcal{I}}\cdot f_{\mathcal{I}}(t)+o(f_{\mathcal{I}}(t))\quad\text{for each problem instance $\mathcal{I}$ and all rounds $t$}. \tag{66}
$$
Here $f_{\mathcal{I}}(·)$ defines the asymptotic shape of the regret bound, and $c_{\mathcal{I}}$ is the leading constant that cannot depend on time $t$ . Both $f_{\mathcal{I}}$ and $c_{\mathcal{I}}$ may depend on the problem instance $\mathcal{I}$ . Depending on a particular result, either of them could be worst-case, i.e., the same for all problem instances on a given metric space. The subtlety is that the instance-dependent vs. worst-case distinction can be applied to $f_{\mathcal{I}}$ and $c_{\mathcal{I}}$ separately, see Table 1. Indeed, both are worst-case in this chapterâs results on uniform discretization. In Theorem 4.18 for adaptive discretization, $f_{\mathcal{I}}(t)$ is instance-dependent, driven by the zooming dimension, whereas $c_{\mathcal{I}}$ is an absolute constant. In contrast, the $\log(t)$ regret bound for stochastic bandits with finitely many arms features a worst-case $f_{\mathcal{I}}$ and instance-dependent constant $c_{\mathcal{I}}$ . (We are not aware of any results in which both $c_{\mathcal{I}}$ and $f_{\mathcal{I}}$ are instance-dependent.) Recall that we have essentially matching upper and lower bounds for uniform dicretization and for the dependence on the zooming dimension, the top two quadrants in Table 1. The bottom-left quadrant is quite intricate for infinitely many arms, as we discuss next.
Per-metric optimal regret rates. We are interested in regret rates (66), where $c_{\mathcal{I}}$ is instance-dependent, but $f_{\mathcal{I}}=f$ is the same for all problem instances on a given metric space; we abbreviate this as $O_{\mathcal{I}}(f(t))$ . The upper/lower bounds for stochastic bandits imply that $O_{\mathcal{I}}(\log t)$ regret is feasible and optimal for finitely many arms, regardless of the metric space. Further, the $\Omega(T^{1-1/(d+2)})$ lower bound for $\left([0,1],\,\ell_{2}^{1/d}\right)$ , $dâ„ 1$ in Theorem 4.12 holds even if we allow an instance-dependent constant (Kleinberg, 2004). The construction in this result is similar to that in Section 20.2, but more complex. It needs to âworkâ for all times $t$ , so it contains bump functions (54) for all scales $\epsilon$ simultaneously. This lower bound extends to metric spaces with covering dimension $d$ , under a homogeneity condition (Kleinberg et al., 2008b, 2019).
However, better regret rates may be possible for arbitrary infinite metric spaces. The most intuitive example involves a âfat pointâ $xâ X$ such that cutting out any open neighborhood of $x$ reduces the covering dimension by at least $\epsilon>0$ . Then one can obtain a regret rate âas ifâ the covering dimension were $d-\epsilon$ . Kleinberg et al. (2008b, 2019) handle this phenomenon in full generality. For an arbitrary infinite metric space, they define a ârefinementâ of the covering dimension, denoted $\mathtt{MaxMinCOV}(X)$ , and prove matching upper and lower regret bounds âas ifâ the covering dimension were equal to this refinement. $\mathtt{MaxMinCOV}(X)$ is always upper-bounded by $\mathtt{COV}_{c}(X)$ , and could be as low as $0$ depending on the metric space. Their algorithm is a version of the zooming algorithm with quotas on the number of active arms in some regions of the metric space. Further, Kleinberg and Slivkins (2010); Kleinberg et al. (2019) prove that the transition from $O_{\mathcal{I}}(\log t)$ to $O_{\mathcal{I}}(\sqrt{t})$ regret is sharp and corresponds to the distinction between countable and uncountable set of arms. The full characterization of optimal regret rates is summarized in Table 2. This work makes deep connections between bandit algorithms, metric topology, and transfinite ordinal numbers.
| If the metric completion of $(X,\mathcal{D})$ is ⊠| then regret can be ⊠| but not ⊠|
| --- | --- | --- |
| finite | $O(\log t)$ | $o(\log t)$ |
| compact and countable | $\omega(\log t)$ | $O(\log t)$ |
| compact and uncountable | | |
| $\mathtt{MaxMinCOV}=0$ | $\tilde{O}\left(t^{\gamma}\right)$ , $\gamma>\nicefrac{{1}}{{2}}$ | $o(\sqrt{t})$ |
| $\mathtt{MaxMinCOV}=dâ(0,â)$ | $\tilde{O}\left(t^{\gamma}\right)$ , $\gamma>\tfrac{d+1}{d+2}$ | $o\left(t^{\gamma}\right)$ , $\gamma<\tfrac{d+1}{d+2}$ |
| $\mathtt{MaxMinCOV}=â$ | $o(t)$ | $O\left(t^{\gamma}\right)$ , $\gamma<1$ |
| non-compact | $O(t)$ | $o(t)$ |
Table 2: Per-metric optimal regret bounds for Lipschitz MAB
Kleinberg and Slivkins (2010); Kleinberg et al. (2019) derive a similar characterization for a version of Lipschitz bandits with full feedback, i.e., when the algorithm receives feedback for all arms. $O_{\mathcal{I}}(\sqrt{t})$ regret is feasible for any metric space of finite covering dimension. One needs an exponentially weaker version of covering dimension to induce regret bounds of the form $\tilde{O}_{\mathcal{I}}(t^{\gamma})$ , for some $\gammaâ(\nicefrac{{1}}{{2}},1)$ .
Per-instance optimality. What is the best regret bound for a given instance of Lipschitz MAB? Magureanu et al. (2014) ask this question in the style of Lai-Robbins lower bound for stochastic bandits (Theorem 2.14). Specifically, they consider finite metric spaces, assume that the algorithm satisfies (32), the precondition in Theorem 2.14, and focus on optimizing the leading constant $c_{\mathcal{I}}$ in Eq. (66) with $f(t)=\log(t)$ . For an arbitrary problem instance with finitely many arms, they derive a lower bound on $c_{\mathcal{I}}$ , and provide an algorithm comes arbitrarily close to this lower bound. However, this approach may increase the $o(\log T)$ term in Eq. (66), possibly hurting the worst-case performance.
Beyond IID rewards. Uniform discretization easily extends for adversarial rewards (Kleinberg, 2004), and matches the regret bound in Theorem 4.11 (see Exercise 6.2). Adaptive discretization extends to adversarial rewards, too, albeit with much additional work: Podimata and Slivkins (2021) connect it to techniques from adversarial bandits, and generalize Theorem 4.18 for a suitable version of zooming dimension.
Some other variants with non-IID rewards have been studied. Maillard and Munos (2010) consider a full-feedback problem with adversarial rewards and Lipschitz condition in the Euclidean space $(\mathbb{R}^{d},\ell_{2})$ , achieving a surprisingly strong regret bound of $O_{d}(\sqrt{T})$ . Azar et al. (2014) consider a version in which the IID condition is replaced by more sophisticated ergodicity and mixing assumptions, and essentially recover the performance of the zooming algorithm. Slivkins (2014) extends the zooming algorithm to a version of Lipschitz bandits where expected rewards do not change too fast over time. Specifically, $\mu(x,t)$ , the expected reward of a given arm $x$ at time $t$ , is Lipschitz relative to a known metric on pairs $(x,t)$ . Here round $t$ is interpreted as a context in Lipschitz contextual bandits; see also Section 42 and the literature discussion in Section 47.
23.2 Partial similarity information
Numerical similarity information required for the Lipschitz bandits may be difficult to obtain in practice. A canonical example is the âtaxonomy banditsâ problem mentioned above, where an algorithm is given a taxonomy (a tree) on arms but not a metric which admits the Lipschitz condition (57). One goal here is to obtain regret bounds that are (almost) as good as if the metric were known.
Slivkins (2011) considers the metric implicitly defined by an instance of taxonomy bandits: the distance between any two arms is the âwidthâ of their least common subtree $S$ , where the width of $S$ is defined as $W(S):=\max_{x,yâ S}|\mu(x)-\mu(y)|$ . (Note that $W(S)$ is not known to the algorithm.) This is the best possible metric, i.e., a metric with smallest distances, that admits the Lipschitz condition (57). Slivkins (2011) puts forward an extension of the zooming algorithm which partially reconstructs the implicit metric, and almost matches the regret bounds of the zooming algorithm for this metric. In doing so, it needs to deal with another exploration-exploitation tradeoff: between learning more about the widths and exploiting this knowledge to run the zooming algorithm. The idea is to have âactive subtreesâ $S$ rather than âactive armsâ, maintain a lower confidence bound (LCB) on $W(S)$ , and use it instead of the true width. The LCB can be obtained any two sub-subtrees $S_{1}$ , $S_{2}$ of $S$ . Indeed, if one chooses arms from $S$ at random according to some fixed distribution, then $W(S)â„|\mu(S_{1})-\mu(S_{2})|$ , where $\mu(S_{i})$ is the expected reward when sampling from $S_{i}$ , and with enough samples the empirical average reward from $S_{i}$ is close to its expectation. The regret bound depends on the âquality parameterâ: essentially, how deeply does one need to look in each subtree $S$ in order to find sub-subtrees $S_{1},S_{2}$ that give a sufficiently good lower bound on $W(S)$ . However, the algorithm does not need to know this parameter upfront. Bull (2015) considers a somewhat more general setting where multiple taxonomies on arms are available, and some of them may work better for this problem than others. He carefully traces out the conditions under which one can achieve $\tilde{O}(\sqrt{T})$ regret.
A similar issue arises when arms correspond to points in $[0,1]$ but no Lipschitz condition is given. This setting can be reduced to âtaxonomy banditsâ by positing a particular taxonomy on arms, e.g., the root corresponds to $[0,1]$ , its children are $[0,\nicefrac{{1}}{{2}})$ and $[\nicefrac{{1}}{{2}},1]$ , and so forth splitting each interval into halves.
Ho et al. (2016) consider a related problem in the context of crowdsourcing markets. Here the algorithm is an employer who offers a quality-contingent contract to each arriving worker, and adjusts the contract over time. On an abstract level, this is a bandit problem in which arms are contracts: essentially, vectors of prices. However, there is no Lipschitz-like assumption. Ho et al. (2016) treat this problem as a version of âtaxonomy banditsâ, and design a version of the zooming algorithm. They estimate the implicit metric in a problem-specific way, taking advantage of the structure provided by the employer-worker interactions, and avoid the dependence on the âquality parameterâ from Slivkins (2011).
Another line of work studies the âpure explorationâ version of âtaxonomy banditsâ, where the goal is to output a âpredicted best armâ with small instantaneous regret (Munos, 2011; Valko et al., 2013; Grill et al., 2015), see Munos (2014) for a survey. The main result essentially recovers the regret bounds for the zooming algorithm as if a suitable distance function were given upfront. The algorithm posits a parameterized family of distance functions, guesses the parameters, and runs a zooming-like algorithm for each guess.
Bubeck et al. (2011c) study a version of continuum-armed bandits with strategy set $[0,1]^{d}$ and Lipschitz constant $L$ that is not revealed to the algorithm, and match the regret rate in Theorem 4.2. This result is powered by an assumption that $\mu(·)$ is twice differentiable, and a bound on the second derivative is known to the algorithm. Minsker (2013) considers the same strategy set, under metric $\|x-y\|_{â}^{\beta}$ , where the âsmoothness parameterâ $\betaâ(0,1]$ is not known. His algorithm achieves near-optimal instantaneous regret as if the $\beta$ were known, under some structural assumptions.
23.3 Generic non-Lipschitz models for bandits with similarity
One drawback of Lipschitz bandits as a model is that the distance $\mathcal{D}(x,y)$ only gives a âworst-caseâ notion of similarity between arms $x$ and $y$ . In particular, the distances may need to be very large in order to accommodate a few outliers, which would make $\mathcal{D}$ less informative elsewhere. This concern is partially addressed by relaxing the Lipschitz condition in the analysis of the zooming algorithm. With this criticism in mind, Srinivas et al. (2010); Krause and Ong (2011); Desautels et al. (2012) define a probabilistic model, called Gaussian Processes Bandits, where the expected payoff function is distributed according to a suitable Gaussian Process on $X$ , thus ensuring a notion of âprobabilistic smoothnessâ with respect to $X$ .
Krishnamurthy et al. (2020) side-step Lipschitz assumptions by relaxing the benchmark. They define a new benchmark, which replaces each arm $a$ with a low-variance distribution around this arm, called the smoothed arm, and compares the algorithmâs reward to that of the best smoothed arm; call it the smoothed benchmark. For example, if the set of arms is $[0,1]$ , then the smoothed arm can be defined as the uniform distribution on the interval $[a-\epsilon,a+\epsilon]$ , for some fixed $\epsilon>0$ . Thus, very sharp peaks in the mean rewards â which are impossible to handle via the standard best-arm benchmark without Lipschitz assumptions â are now smoothed over an interval. In the most general version, the smoothing distribution may be arbitrary, and arms may lie in an arbitrary âambient spaceâ rather than $[0,1]$ interval. (The âambient spaceâ is supposed to be natural given the application domain; formally it is described by a metric on arms and a measure on balls in that metric.) Both fixed and adaptive discretization carries over to the smoothed benchmark, without any Lipschitz assumptions (Krishnamurthy et al., 2020). These results usefully extend to contextual bandits with policy sets, as defined in Section 44 (Krishnamurthy et al., 2020; Majzoubi et al., 2020).
Amin et al. (2011) and Combes et al. (2017) consider stochastic bandits with, essentially, an arbitrary known family $\mathcal{F}$ of mean reward functions, as per Section 4. Amin et al. (2011) posit a finite $|\mathcal{F}|$ and obtain a favourable regret bound when a certain complexity measure of $\mathcal{F}$ is small, and any two functions in $\mathcal{F}$ are sufficiently well-separated. However, their results do not subsume any prior work on Lipschitz bandits. Combes et al. (2017) extend the per-instance optimality approach from Magureanu et al. (2014), discussed above, from Lipschitz bandits to an arbitrary $\mathcal{F}$ , under mild assumptions.
Unimodal bandits assume that mean rewards are unimodal: e.g., when the set of arms is $X=[0,1]$ , there is a single best arm $x^{*}$ , and mean rewards $\mu(x)$ increase for all arms $x<x^{*}$ and decrease for all arms $x>x^{*}$ . For this setting, one can obtain $\tilde{O}(\sqrt{T})$ regret under some additional assumptions on $\mu(·)$ : smoothness (Cope, 2009), Lipschitzness (Yu and Mannor, 2011), or continuity (Combes and ProutiÚre, 2014a). One can also consider a more general version of unimodality relative to a known partial order on arms (Yu and Mannor, 2011; Combes and ProutiÚre, 2014b).
23.4 Dynamic pricing and bidding
A notable class of bandit problems has arms that correspond to monetary amounts, e.g., offered prices for selling (dynamic pricing) or bying (dynamic procurement), offered wages for hiring, or bids in an auction (dynamic bidding). Most studied is the basic case when arms are real numbers, e.g., prices rather than price vectors. All these problems satisfy a version of monotonicity, e.g., decreasing the price cannot result in fewer sales. This property suffices for both uniform and adaptive discretization without any additional Lipschitz assumptions. We work this out for dynamic pricing, see the exercises in Section 24.4.
Dynamic pricing as a bandit problem has been introduced in Kleinberg and Leighton (2003), building on the earlier work (Blum et al., 2003). Kleinberg and Leighton (2003) introduce uniform discretization, and observe that it attains $\tilde{O}(T^{2/3})$ regret for stochastic rewards, just like in Section 20.1, and likewise for adversarial rewards, with an appropriate algorithm for adversarial bandits. Moreover, uniform discretization (with a different step $\epsilon$ ) achieves $\tilde{O}(\sqrt{T})$ regret, if expected reward $\mu(x)$ is strongly concave as a function of price $x$ ; this condition, known as regular demands, is standard in theoretical economics. Kleinberg and Leighton (2003) prove a matching $\Omega(T^{2/3})$ lower bound in the worst case, even if one allows an instance-dependent constant. The construction contains a version of bump functions (54) for all scales $\epsilon$ simultaneously, and predates a similar lower bound for continuum-armed bandits from Kleinberg (2004). That the zooming algorithm works without additional assumptions is straightforward from the original analysis in (Kleinberg et al., 2008b, 2019), but has not been observed until Podimata and Slivkins (2021).
$\tilde{O}(\sqrt{T})$ regret can be achieved in some auction-related problems when additional feedback is available to the algorithm. Weed et al. (2016) achieve $\tilde{O}(\sqrt{T})$ regret for dynamic bidding in first-price auctions, when the algorithm observes full feedback (i.e., the minimal winning bid) whenever it wins the auction. Feng et al. (2018) simplifies the algorithm in this result, and extends it to a more general auction model. Both results extend to adversarial outcomes. Cesa-Bianchi et al. (2013) achieve $\tilde{O}(\sqrt{T})$ regret in a âdualâ problem, where the algorithm optimizes the auction rather than the bids. Specifically, the algorithm adjusts the reserve price (the lowest acceptable bid) in a second-price auction. The algorithm receives more-than-bandit feedback: indeed, if a sale happens for a particular reserve price, then exactly the same sale would have happened for any smaller reserve price.
Dynamic pricing and related problems become more difficult when arms are price vectors, e.g., when multiple products are for sale, the algorithm can adjust the price for each separately, and customer response for one product depends on the prices for others. In particular, one needs structural assumptions such as Lipschitzness, concavity or linearity. One exception is quality-contingent contract design (Ho et al., 2016), as discussed in Section 23.2, where a version of zooming algorithm works without additional assumptions.
Dynamic pricing and bidding is often studied in more complex environments with supply/budget constraints and/or forward-looking strategic behavior. We discuss these issues in Chapters 9 and 10. In particular, the literature on dynamic pricing with limited supply is reviewed in Section 59.5.
24 Exercises and hints
24.1 Construction of $\epsilon$ -meshes
Let us argue that the construction in Remark 4.6 attains the infimum in (58) up to a constant factor.
Let $\epsilon(S)=âf\left\{\,\epsilon>0:\;\text{$S$ is an $\epsilon$-mesh}\,\right\}$ , for $Sâ X$ . Restate the right-hand side in (58) as
$$
\displaystyle\inf_{S\subset X}f(S)\text{,~~where }f(S)=c_{\mathtt{ALG}}\cdot\sqrt{|S|\,T\log T}+T\cdot\epsilon(S). \tag{67}
$$
Recall that $\operatornamewithlimits{\mathbb{E}}[R(T)]†f(S)$ if we run algorithm $\mathtt{ALG}$ on set $S$ of arms.
Recall the construction in Remark 4.6. Let $\mathcal{N}_{i}$ be the $\epsilon$ -mesh computed therein for a given $\epsilon=2^{-i}$ . Suppose the construction stops at some $i=i^{*}$ . Thus, this construction gives regret $\operatornamewithlimits{\mathbb{E}}[R(T)]†f(N_{i^{*}})$ .
**Exercise 4.1**
*Compare $f(N_{i^{*}})$ against (67). Specifically, prove that
$$
\displaystyle f(\mathcal{N}_{i^{*}})\leq 16\,\inf_{S\subset X}f(S). \tag{68}
$$
The key notion in the proof is $\epsilon$ -net, $\epsilon>0$ : it is an $\epsilon$ -mesh where any two points are at distance $>\epsilon$ . - Observe that each $\epsilon$ -mesh computed in Remark 4.6 is in fact an $\epsilon$ -net.
- Prove that for any $\epsilon$ -mesh $S$ and any $\epsilon^{\prime}$ -net $\mathcal{N}$ , $\epsilon^{\prime}â„ 2\epsilon$ , it holds that $|\mathcal{N}|â€|S|$ . Use (a) to conclude that $\min_{iâ\mathbb{N}}f(\mathcal{N}_{i})†4\,f(S)$ .
- Prove that $f(\mathcal{N}_{i^{*}})†4\,\min_{iâ\mathbb{N}}f(\mathcal{N}_{i})$ . Use (b) to conclude that (68) holds.*
24.2 Lower bounds for uniform discretization
**Exercise 4.2**
*Extend the construction and analysis in Section 20.2:
- ⊠from Lipschitz constant $L=1$ to an arbitrary $L$ , i.e., prove Theorem 4.2.
- ⊠from continuum-armed bandits to $\left([0,1],\,\ell_{2}^{1/d}\right)$ , i.e., prove Theorem 4.12.
- ⊠to an arbitrary metric space $(X,\mathcal{D})$ and an arbitrary $\epsilon$ -net $\mathcal{N}$ therein (see Exercise 4.1): prove that for any algorithm there is a problem instance on $(X,\mathcal{D})$ such that
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}[R(T)]\geq\Omega\left(\,\min\left(\,\epsilon T,\,|\mathcal{N}|/\epsilon\,\right)\,\right)\quad\text{for any time horizon $T$}. \tag{69}
$$*
**Exercise 4.3**
*Prove that the optimal uniform discretization from Eq. (58) is optimal up to $O(\log T)$ factors. Specifically, using the notation from Eq. (67), prove the following: for any metric space $(X,\mathcal{D})$ , any algorithm and any time horizon $T$ there is a problem instance on $(X,\mathcal{D})$ such that
$$
\operatornamewithlimits{\mathbb{E}}[R(T)]\geq\textstyle\widetilde{\Omega}(\;\inf_{S\subset X}f(S)\;).
$$*
**Exercise 4.4 (Lower bounds via covering dimension)**
*Consider Lipschitz bandits in a metric space $(X,\mathcal{D})$ . Fix $d<\mathtt{COV}_{c}(X)$ , for some fixed absolute constant $c>0$ . Fix an arbitrary algorithm $\mathtt{ALG}$ . We are interested proving that this algorithm suffers lower bounds of the form
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}[R(T)]\geq\Omega\left(\,T^{(d+1)/(d+2)}\,\right). \tag{70}
$$
The subtlety is, for which $T$ can this be achieved?
- Assume that the covering property is nearly tight at a particular scale $\epsilon>0$ , namely:
$$
\displaystyle N_{\epsilon}(X)\geq c^{\prime}\cdot\epsilon^{-d}\quad\text{for some absolute constant $c^{\prime}$.} \tag{71}
$$
Prove that (70) holds for some problem instance and $T=c^{\prime}·\epsilon^{-d-2}$ .
- Assume (71) holds for all $\epsilon>0$ . Prove that for each $T$ there is a problem instance with (70).
- Prove that (70) holds for some time horizon $T$ and some problem instance.
- Assume that $d<\mathtt{COV}(X):=âf_{c>0}\mathtt{COV}_{c}(X)$ . Prove that there are infinitely many time horizons $T$ such that (70) holds for some problem instance $\mathcal{I}_{T}$ . In fact, there is a distribution over these problem instances (each endowed with an infinite time horizon) such that (70) holds for infinitely many $T$ . Hints: Part (a) follows from Exercise 4.2 (c), the rest follows from part (a). For part (c), observe that (71) holds for some $\epsilon$ . For part (d), observe that (71) holds for arbitrarily small $\epsilon>0$ , e.g., with $c^{\prime}=1$ , then apply part (a) to each such $\epsilon$ . To construct the distribution over problem instances $\mathcal{I}_{T}$ , choose a sufficiently sparse sequence $(T_{i}:\,iâ\mathbb{N})$ , and include each instance $\mathcal{I}_{T_{i}}$ with probability $\sim 1/\log(T_{i})$ , say. To remove the $\log T$ factor from the lower bound, carry out the argument above for some $d^{\prime}â(d,\mathtt{COV}_{c}(X))$ .*
24.3 Examples and extensions
**Exercise 4.5 (Covering dimension and zooming dimension)**
*- Prove that the covering dimension of $\left([0,1]^{d},\ell_{2}\right)$ , $dâ\mathbb{N}$ and $\left([0,1],\,\ell_{2}^{1/d}\right)$ , $dâ„ 1$ is $d$ .
- Prove that the zooming dimension cannot exceed the covering dimension. More precisely: if $d=\mathtt{COV}_{c}(X)$ , then the zooming dimension with multiplier $3^{d}· c$ is at most $d$ .
- Construct an example in which the zooming dimension is much smaller than $\mathtt{COV}_{c}(X)$ .*
**Exercise 4.6 (Lipschitz bandits with a target set)**
*Consider Lipschitz bandits on metric space $(X,\mathcal{D})$ with $\mathcal{D}(·,·)â€\nicefrac{{1}}{{2}}$ . Fix the best reward $\mu^{*}â[\nicefrac{{3}}{{4}},1]$ and a subset $Sâ X$ and assume that
$$
\mu(x)=\mu^{*}-\mathcal{D}(x,S)\quad\forall x\in X,\qquad\text{where }\mathcal{D}(x,S):=\inf_{y\in S}\mathcal{D}(x,y).
$$
In words, the mean reward is determined by the distance to some âtarget setâ $S$ .
- Prove that $\mu^{*}-\mu(x)â€\mathcal{D}(x,S)$ for all arms $x$ , and that this condition suffices for the analysis of the zooming algorithm, instead of the full Lipschitz condition (57).
- Assume the metric space is $([0,1]^{d},\ell_{2})$ , for some $dâ\mathbb{N}$ . Prove that the zooming dimension of the problem instance (with a suitably chosen multiplier) is at most the covering dimension of $S$ . Take-away: In part (b), the zooming algorithm achieves regret $\tilde{O}(T^{(b+1)/(b+2)})$ , where $b$ is the covering dimension of the target set $S$ . Note that $b$ could be much smaller than $d$ , the covering dimension of the entire metric space. In particular, one achieves regret $\tilde{O}(\sqrt{T})$ if $S$ is finite.*
24.4 Dynamic pricing
Let us apply the machinery from this chapter to dynamic pricing. This problem naturally satisfies a monotonicity condition: essentially, you cannot sell less if you decrease the price. Interestingly, this condition suffices for our purposes, without any additional Lipschitz assumptions.
Problem protocol: Dynamic pricing
In each round $tâ[T]$ :
- Algorithm picks some price $p_{t}â[0,1]$ and offers one item for sale at this price.
- A new customer arrives with private value $v_{t}â[0,1]$ , not visible to the algorithm.
- The customer buys the item if and only if $v_{t}â„ p_{t}$ . The algorithmâs reward is $p_{t}$ if there is a sale, and $0$ otherwise.
Thus, arms are prices in $X=[0,1]$ . We focus on stochastic dynamic pricing: each private value $v_{t}$ is sampled independently from some fixed distribution which is not known to the algorithm.
**Exercise 4.7 (monotonicity)**
*Observe that the sale probability $\Pr[\text{sale at price $p$}]$ is monotonically non-increasing in $p$ . Use this monotonicity property to derive one-sided Lipschitzness:
$$
\displaystyle\mu(p)-\mu(p^{\prime})\leq p-p^{\prime}\quad\text{for any two prices $p>p^{\prime}$}. \tag{72}
$$*
**Exercise 4.8 (uniform discretization)**
*Use (72) to recover the regret bound for uniform discretization: with any algorithm $\mathtt{ALG}$ satisfying (52) and discretization step $\epsilon=(T/\log T)^{-1/3}$ one obtains
$$
\operatornamewithlimits{\mathbb{E}}[R(T)]\leq T^{2/3}\cdot(1+c_{\mathtt{ALG}})(\log T)^{1/3}.
$$*
**Exercise 4.9 (adaptive discretization)**
*Modify the zooming algorithm as follows. The confidence ball of arm $x$ is redefined as the interval $[x,\,x+r_{t}(x)]$ . In the activation rule, when some arm is not covered by the confidence balls of active arms, pick the smallest (infimum) such arm and activate it. Prove that this modified algorithm achieves the regret bound in Theorem 4.18. Hint: The invariant (62) still holds. The one-sided Lipschitzness (72) suffices for the proof of Lemma 4.14.*
Chapter 5 Full Feedback and Adversarial Costs
For this one chapter, we shift our focus from bandit feedback to full feedback. As the IID assumption makes the problem âtoo easyâ, we introduce and study the other extreme, when rewards/costs are chosen by an adversary. We define and analyze two classic algorithms, weighted majority and multiplicative-weights update, a.k.a. $\mathtt{Hedge}$ .
Full feedback is defined as follows: in the end of each round, the algorithm observes the outcome not only for the chosen arm, but for all other arms as well. To be in line with the literature on such problems, we express the outcomes as costs rather than rewards. As IID costs are quite âeasyâ with full feedback, we consider the other extreme: costs can arbitrarily change over time, as if they are selected by an adversary.
The protocol for full feedback and adversarial costs is as follows:
Problem protocol: Bandits with full feedback and adversarial costs
Parameters: $K$ arms, $T$ rounds (both known).
In each round $tâ[T]$ :
- Adversary chooses costs $c_{t}(a)â„ 0$ for each arm $aâ[K]$ .
- Algorithm picks arm $a_{t}â[K]$ .
- Algorithm incurs cost $c_{t}(a_{t})$ for the chosen arm.
- The costs of all arms, $c_{t}(a):\;aâ[K]$ , are revealed.
**Remark 5.1**
*While some results rely on bounded costs, e.g., $c_{t}(a)†1$ , we do not assume this by default.*
One real-life scenario with full feedback is investments on a stock market. For a simple (and very stylized) example, recall one from the Introduction. Suppose each morning choose one stock and invest $1 into it. At the end of the day, we observe not only the price of the chosen stock, but prices of all stocks. Based on this feedback, we determine which stock to invest for the next day.
A paradigmatic special case of bandits with full feedback is sequential prediction with experts advice. Suppose we need to predict labels for observations, and we are assisted with a committee of experts. In each round, a new observation arrives, and each expert predicts a correct label for it. We listen to the experts, and pick an answer to respond. We then observe the correct answer and costs/penalties of all other answers. Such a process can be described by the following protocol:
Problem protocol: Sequential prediction with expert advice
Parameters: $K$ experts, $T$ rounds, $L$ labels, observation set $\mathcal{X}$ (all known).
For each round $tâ[T]$ :
- Adversary chooses observation $x_{t}â\mathcal{X}$ and correct label $z^{*}_{t}â[L]$ . Observation $x_{t}$ is revealed, label $z^{*}_{t}$ is not.
- The $K$ experts predict labels $z_{1,t},...,z_{K,t}â[L]$ .
- Algorithm picks an expert $e=e_{t}â[K]$ .
- Correct label $z^{*}_{t}$ is revealed.
- Algorithm incurs cost $c_{t}=c\left(\,z_{e,t},\,z^{*}_{t}\,\right)$ , for some known cost function $c:[L]Ă[L]â[0,â)$ .
The basic case is binary costs: $c(z,z^{*})={\bf 1}_{\left\{\,zâ z^{*}\,\right\}}$ , i.e., the cost is $0$ if the answer is correct, and $1$ otherwise. Then the total cost is simply the number of mistakes.
The goal is to do approximately as well as the best expert. Surprisingly, this can be done without any domain knowledge, as explained in the rest of this chapter.
**Remark 5.2**
*Because of this special case, the general case of bandits with full feedback is usually called online learning with experts, and defined in terms of costs (as penalties for incorrect predictions) rather than rewards. We will talk about arms, actions and experts interchangeably throughout this chapter.*
**Remark 5.3 (IID costs)**
*Consider the special case when the adversary chooses the cost $c_{t}(a)â[0,1]$ of each arm $a$ from some fixed distribution $\mathcal{D}_{a}$ , same for all rounds $t$ . With full feedback, this special case is âeasyâ: indeed, there is no need to explore, since costs of all arms are revealed after each round. With a naive strategy such as playing arm with the lowest average cost, one can achieve regret $O\left(\sqrt{T\log\left(KT\right)}\right)$ . Further, there is a nearly matching lower regret bound $\Omega(\sqrt{T}+\log K)$ . The proofs of these results are left as exercise. The upper bound can be proved by a simple application of clean event/confidence radius technique that weâve been using since Chapter 1. The $\sqrt{T}$ lower bound follows from the same argument as the bandit lower bound for two arms in Chapter 2, as this argument does not rely on bandit feedback. The $\Omega(\log K)$ lower bound holds for a simple special case, see Theorem 5.8.*
25 Setup: adversaries and regret
Let us elaborate on the types of adversaries one could consider, and the appropriate notions of regret. A crucial distinction is whether the cost functions $c_{t}(·)$ depend on the algorithmâs choices. An adversary is called oblivious if they donât, and adaptive if they do (i.e., oblivious / adaptive to the algorithm). Like before, the âbest armâ is an arm $a$ with a lowest total cost, denoted $\mathtt{cost}(a)=\sum_{t=1}^{T}c_{t}(a)$ , and regret is the difference in total cost compared to this arm. However, defining this precisely is a little subtle, especially when the adversary is randomized. We explain all this in detail below.
Deterministic oblivious adversary. Thus, the costs $c_{t}(·)$ , $tâ[T]$ are deterministic and do not depend on the algorithmâs choices. Without loss of generality, the entire âcost tableâ $\left(\,c_{t}(a):\;aâ[K],\,tâ[T]\,\right)$ is chosen before round $1$ . The best arm is naturally defined as $\operatornamewithlimits{argmin}_{aâ[K]}\mathtt{cost}(a)$ , and regret is defined as
$$
\displaystyle R(T)=\mathtt{cost}(\mathtt{ALG})-\min_{a\in[K]}\mathtt{cost}(a), \tag{73}
$$
where $\mathtt{cost}(\mathtt{ALG})$ denotes the total cost incurred by the algorithm. One drawback of such adversary is that it does not model IID costs, even though IID rewards are a simple special case of adversarial rewards.
Randomized oblivious adversary. The costs $c_{t}(·)$ , $tâ[T]$ do not depend on the algorithmâs choices, as before, but can be randomized. Equivalently, the adversary fixes a distribution $\mathcal{D}$ over the cost tables before round $1$ , and then draws a cost table from this distribution. Then IID costs are indeed a simple special case. Since $\mathtt{cost}(a)$ is now a random variable, there are two natural (and different) ways to define the âbest armâ:
- $\operatornamewithlimits{argmin}_{a}\mathtt{cost}(a)$ : this is the best arm in hindsight, i.e., after all costs have been observed. It is a natural notion if we start from the deterministic oblivious adversary.
- $\operatornamewithlimits{argmin}_{a}\operatornamewithlimits{\mathbb{E}}[\mathtt{cost}(a)]$ : this is be best arm in foresight, i.e., an arm youâd pick if you only know the distribution $\mathcal{D}$ . This is a natural notion if we start from IID costs.
Accordingly, there are two natural versions of regret: with respect to the best-in-hindsight arm, as in (73), and with respect to the best-in-foresight arm,
$$
\displaystyle R(T)=\mathtt{cost}(\mathtt{ALG})-\min_{a\in[K]}\operatornamewithlimits{\mathbb{E}}[\mathtt{cost}(a)]. \tag{74}
$$
For IID costs, this notion coincides with the definition of regret from Chapter 1.
**Remark 5.4**
*The notion in (73) is usually referred to simply as regret in the literature, whereas (74) is often called pseudo-regret. We will use this terminology when we need to distinguish between the two versions.*
**Remark 5.5**
*Pseudo-regret cannot exceed regret, because the best-in-foresight arm is a weaker benchmark. Some positive results for pseudo-regret carry over to regret, and some donât. For IID rewards/costs, the $\sqrt{T}$ upper regret bounds from Chapter 1 extend to regret, whereas the $\log(T)$ upper regret bounds do not extend in full generality, see Exercise 5.2 for details.*
Adaptive adversary can change the costs depending on the algorithmâs past choices. Formally, in each round $t$ , the costs $c_{t}(·)$ may depend on arms $a_{1}\,,\ ...\ ,a_{t-1}$ , but not on $a_{t}$ or the realization of algorithmâs internal randomness. This models scenarios when algorithmâs actions may alter the environment that the algorithm operates in. For example:
- an algorithm that adjusts the layout of a website may cause users to permanently change their behavior, e.g., they may gradually get used to a new design, and get dissatisfied with the old one.
- a bandit algorithm that selects news articles for a website may attract some users and repel some others, and/or cause the users to alter their reading preferences.
- if a dynamic pricing algorithm offers a discount on a new product, it may cause many people to buy this product and (eventually) grow to like it and spread the good word. Then more people would be willing to buy this product at full price.
- if a bandit algorithm adjusts the parameters of a repeated auction (e.g., a reserve price), auction participants may adjust their behavior over time, as they become more familiar with the algorithm.
In game-theoretic applications, adaptive adversary can be used to model a game between an algorithm and a self-interested agent that responds to algorithmâs moves and strives to optimize its own utility. In particular, the agent may strive to hurt the algorithm if the game is zero-sum. We will touch upon game-theoretic applications in Chapter 9.
An adaptive adversary is assumed to be randomized by default. In particular, this is because the adversary can adapt the costs to the algorithmâs choice of arms in the past, and the algorithm is usually randomized. Thus, the distinction between regret and pseudo-regret comes into play again.
Crucially, which arm is best may depend on the algorithmâs actions. For example, if an algorithm always chooses arm 1 then arm 2 is consistently much better, whereas if the algorithm always played arm 2, then arm 1 may have been better. One can side-step these issues by considering the best-observed arm: the best-in-hindsight arm according to the costs actually observed by the algorithm.
Regret guarantees relative to the best-observed arm are not always satisfactory, due to many problematic examples such as the one above. However, such guarantees are worth studying for several reasons. First, they are meaningful in some scenarios, e.g., when algorithmâs actions do not substantially affect the total cost of the best arm. Second, such guarantees may be used as a tool to prove results on oblivious adversaries (e.g., see next chapter). Third, such guarantees are essential in several important applications to game theory, when a bandit algorithm controls a player in a repeated game (see Chapter 9). Finally, such guarantees often follow from the analysis of oblivious adversary with very little extra work.
Throughout this chapter, we consider an adaptive adversary, unless specified otherwise. We are interested in regret relative to the best-observed arm. For ease of comprehension, one can also interpret the same material as working towards regret guarantees against a randomized-oblivious adversary.
Let us (re-)state some notation: the best arm and its cost are
$$
\textstyle a^{*}\in\operatornamewithlimits{argmin}_{a\in[K]}\mathtt{cost}(a)\quad\text{and}\quad\mathtt{cost}^{*}=\min_{a\in[K]}\mathtt{cost}(a),
$$
where $\mathtt{cost}(a)=\sum_{t=1}^{T}c_{t}(a)$ is the total cost of arm $a$ . Note that $a^{*}$ and $\mathtt{cost}^{*}$ may depend on randomness in rewards, and (for adaptive adversary) also on algorithmâs actions.
As always, $K$ is the number of actions, and $T$ is the time horizon.
26 Initial results: binary prediction with experts advice
We consider binary prediction with experts advice, a special case where expertsâ predictions $z_{i,t}$ can only take two possible values. For example: is this image a face or not? Is it going to rain today or not?
Let us assume that there exists a perfect expert who never makes a mistake. Consider a simple algorithm that disregards all experts who made a mistake in the past, and follows the majority of the remaining experts:
| | In each round $t$ , pick the action chosen by the majority of the experts who did not err in the past. | |
| --- | --- | --- |
We call this the majority vote algorithm. We obtain a strong guarantee for this algorithm:
**Theorem 5.6**
*Consider binary prediction with experts advice. Assuming a perfect expert, the majority vote algorithm makes at most $\log_{2}K$ mistakes, where $K$ is the number of experts.*
* Proof*
Let $S_{t}$ be the set of experts who make no mistakes up to round $t$ , and let $W_{t}=|S_{t}|$ . Note that $W_{1}=K$ , and $W_{t}â„ 1$ for all rounds $t$ , because the perfect expert is always in $S_{t}$ . If the algorithm makes a mistake at round $t$ , then $W_{t+1}†W_{t}/2$ because the majority of experts in $S_{t}$ is wrong and thus excluded from $S_{t+1}$ . It follows that the algorithm cannot make more than $\log_{2}K$ mistakes. â
**Remark 5.7**
*This simple proof introduces a general technique that will be essential in the subsequent proofs: - Define a quantity $W_{t}$ which measures the total remaining amount of âcredibilityâ of the the experts. Make sure that by definition, $W_{1}$ is upper-bounded, and $W_{t}$ does not increase over time. Derive a lower bound on $W_{T}$ from the existence of a âgood expertâ.
- Connect $W_{t}$ with the behavior of the algorithm: prove that $W_{t}$ decreases by a constant factor whenever the algorithm makes mistake / incurs a cost.*
The guarantee in Theorem 5.6 is in fact optimal (the proof is left as Exercise 5.1):
**Theorem 5.8**
*Consider binary prediction with experts advice. For any algorithm, any $T$ and any $K$ , there is a problem instance with a perfect expert such that the algorithm makes at least $\Omega(\min(T,\log K))$ mistakes.*
Let us turn to the more realistic case where there is no perfect expert among the committee. The majority vote algorithm breaks as soon as all experts make at least one mistake (which typically happens quite soon).
Recall that the majority vote algorithm fully trusts each expert until his first mistake, and completely ignores him afterwards. When all experts may make a mistake, we need a more granular notion of trust. We assign a confidence weight $w_{a}â„ 0$ to each expert $a$ : the higher the weight, the larger the confidence. We update the weights over time, decreasing the weight of a given expert whenever he makes a mistake. More specifically, in this case we multiply the weight by a factor $1-\epsilon$ , for some fixed parameter $\epsilon>0$ . We treat each round as a weighted vote among the experts, and we choose a prediction with a largest total weight. This algorithm is called Weighted Majority Algorithm (WMA).
parameter : $\epsilonâ[0,1]$
1exInitialize the weights $w_{i}=1$ for all experts.
For each round $t$ :
Make predictions using weighted majority vote based on $w$ .
For each expert $i$ :
If the $i$ -th expertâs prediction is correct, $w_{i}$ stays the same.
Otherwise, $w_{i}â w_{i}(1-\epsilon)$ .
Algorithm 1 Weighted Majority Algorithm
To analyze the algorithm, we first introduce some notation. Let $w_{t}(a)$ be the weight of expert $a$ before round $t$ , and let $W_{t}=\sum_{a=1}^{K}w_{t}(a)$ be the total weight before round $t$ . Let $S_{t}$ be the set of experts that made incorrect prediction at round $t$ . We will use the following fact about logarithms:
$$
\displaystyle\ln(1-x)<-x\qquad\forall x\in(0,1). \tag{75}
$$
From the algorithm, $W_{1}=K$ and $W_{T+1}>w_{t}(a^{*})=(1-\epsilon)^{\mathtt{cost}^{*}}$ . Therefore, we have
$$
\frac{W_{T+1}}{W_{1}}>\frac{(1-\epsilon)^{\mathtt{cost}^{*}}}{K}. \tag{76}
$$
Since the weights are non-increasing, we must have
$$
W_{t+1}\leq W_{t} \tag{77}
$$
If the algorithm makes mistake at round $t$ , then
| | $\displaystyle W_{t+1}$ | $\displaystyle=\sum_{aâ[K]}w_{t+1}(a)$ | |
| --- | --- | --- | --- |
Since we are using weighted majority vote, the incorrect prediction must have the majority vote:
$$
\sum_{a\in S_{t}}w_{t}(a)\geq\tfrac{1}{2}W_{t}.
$$
Therefore, if the algorithm makes mistake at round $t$ , we have
$$
W_{t+1}\leq(1-\tfrac{\epsilon}{2})W_{t}.
$$
Combining with (76) and (77), we get
$$
\frac{(1-\epsilon)^{\mathtt{cost}^{*}}}{K}<\frac{W_{T+1}}{W_{1}}=\prod_{t=1}^{T}\frac{W_{t+1}}{W_{t}}\leq(1-\tfrac{\epsilon}{2})^{M},
$$
where $M$ is the number of mistakes. Taking logarithm of both sides, we get
$$
\mathtt{cost}^{*}\cdot\ln(1-\epsilon)-\ln{K}<M\cdot\ln(1-\tfrac{\epsilon}{2})<M\cdot(-\tfrac{\epsilon}{2}),
$$
where the last inequality follows from Eq. (75). Rearranging the terms, we get
$$
M<\mathtt{cost}^{*}\cdot\tfrac{2}{\epsilon}\ln(\tfrac{1}{1-\epsilon})+\tfrac{2}{\epsilon}\ln{K}<\tfrac{2}{1-\epsilon}\cdot\mathtt{cost}^{*}+\tfrac{2}{\epsilon}\cdot\ln{K},
$$
where the last step follows from (75) with $x=\frac{\epsilon}{1-\epsilon}$ . To summarize, we have proved:
**Theorem 5.9**
*The number of mistakes made by WMA with parameter $\epsilonâ(0,1)$ is at most
$$
\frac{2}{1-\epsilon}\cdot\mathtt{cost}^{*}+\frac{2}{\epsilon}\cdot\ln{K}.
$$*
**Remark 5.10**
*This bound is very meaningful if $\mathtt{cost}^{*}$ is small, but it does not imply sublinear regret guarantees when $\mathtt{cost}^{*}=\Omega(T)$ . Interestingly, it recovers the $O(\ln K)$ number of mistakes in the special case with a perfect expert, i.e., when $\mathtt{cost}^{*}=0$ .*
27 Hedge Algorithm
We improve over the previous section in two ways: we solve the general case, online learning with experts, and obtain regret bounds that are $o(T)$ and, in fact, optimal. We start with an easy observation that deterministic algorithms are not sufficient for this goal: essentially, any deterministic algorithm can be easily âfooledâ (even) by a deterministic, oblivious adversary.
**Theorem 5.11**
*Consider online learning with $K$ experts and binary costs. Any deterministic algorithm has total cost $T$ for some deterministic, oblivious adversary, even if $\mathtt{cost}^{*}†T/K$ .*
The easy proof is left as Exercise 5.3. Essentially, the adversary knows exactly what the algorithm is going to do in the next round, and can rig the costs to hurt the algorithm.
**Remark 5.12**
*Note that the special case of binary prediction with experts advice is much easier for deterministic algorithms. Indeed, it allows for an âapproximation ratioâ arbitrarily close to $2$ , as in Theorem 5.9, whereas in the general case the âapproximation ratioâ cannot be better than $K$ .*
We define a randomized algorithm for online learning with experts, called $\mathtt{Hedge}$ . This algorithm maintains a weight $w_{t}(a)$ for each arm $a$ , with the same update rule as in WMA (generalized beyond 0-1 costs in a fairly natural way). We need to use a different rule to select an arm, because (i) we need this rule to be randomized, in light of Theorem 5.11, and (ii) the weighted majority rule is not even well-defined in the general case. We use another selection rule, which is also very natural: at each round, choose an arm with probability proportional to the weights. The complete specification is shown in Algorithm 2:
parameter : $\epsilonâ(0,\nicefrac{{1}}{{2}})$
1exInitialize the weights as $w_{1}(a)=1$ for each arm $a$ .
For each round $t$ :
Let $p_{t}(a)=\frac{w_{t}(a)}{\sum_{a^{\prime}=1}^{K}w_{t}(a^{\prime})}$ .
Sample an arm $a_{t}$ from distribution $p_{t}(·)$ .
Observe cost $c_{t}(a)$ for each arm $a$ .
For each arm $a$ , update its weight $w_{t+1}(a)=w_{t}(a)·(1-\epsilon)^{c_{t}(a)}$ .
Algorithm 2 $\mathtt{Hedge}$ algorithm for online learning with experts
Below we analyze $\mathtt{Hedge}$ , and prove $O\left(\,\sqrt{T\log K}\,\right)$ bound on expected regret. We use the same analysis to derive several important extensions, used in the subsequent sections on adversarial bandits.
**Remark 5.13**
*The $O\left(\,\sqrt{T\log K}\,\right)$ regret bound is the best possible for regret. This can be seen on a simple example in which all costs are IID with mean $\nicefrac{{1}}{{2}}$ , see Exercise 5.2 (b). Recall that we also have a $\Omega(\sqrt{T})$ bound for pseudo-regret, due to the lower-bound analysis for two arms in Chapter 2.*
As in the previous section, we use the technique outlined in Remark 5.7, with $W_{t}=\sum_{a=1}^{K}w_{t}(a)$ being the total weight of all arms at round $t$ . Throughout, $\epsilonâ(0,\nicefrac{{1}}{{2}})$ denotes the parameter in the algorithm.
The analysis is not very long but intricate; some find it beautiful. We break it in several distinct steps, for ease of comprehension.
Step 1: easy observations
The weight of each arm after the last round is
$$
w_{T+1}(a)=w_{1}(a)\prod_{t=1}^{T}(1-\epsilon)^{c_{t}(a)}=(1-\epsilon)^{\mathtt{cost}(a)}.
$$
Hence, the total weight of last round satisfies
$$
W_{T+1}>w_{T+1}(a^{*})=(1-\epsilon)^{\mathtt{cost}^{*}}. \tag{78}
$$
From the algorithm, we know that the total initial weight is $W_{1}=K$ .
Step 2: multiplicative decrease in $W_{t}$
We use polynomial upper bounds for $(1-\epsilon)^{x}$ , $x>0$ . We use two variants, stated in a unified form:
$$
\displaystyle(1-\epsilon)^{x}\leq 1-\alpha x+\beta x^{2}\quad\text{for all $x\in[0,u]$}, \tag{79}
$$
where the parameters $\alpha$ , $\beta$ and $u$ may depend on $\epsilon$ but not on $x$ . The two variants are:
- a first-order (i.e., linear) upper bound with $(\alpha,\beta,u)=(\epsilon,0,1)$ ;
- a second-order (i.e., quadratic) upper bound with $\alpha=\ln\left(\,\frac{1}{1-\epsilon}\,\right)$ , $\beta=\alpha^{2}$ and $u=â$ .
We apply Eq. (79) to $x=c_{t}(a)$ , for each round $t$ and each arm $a$ . We continue the analysis for both variants of Eq. (79) simultaneously: thus, we fix $\alpha$ and $\beta$ and assume that $c_{t}(·)†u$ . Then
$$
\displaystyle\frac{W_{t+1}}{W_{t}} \displaystyle=\sum_{a\in[K]}(1-\epsilon)^{c_{t}(a)}\cdot\frac{w_{t}(a)}{W_{t}} \displaystyle<\sum_{a\in[K]}(1-\alpha\,c_{t}(a)+\beta\,c_{t}(a)^{2})\cdot p_{t}(a) \displaystyle=\sum_{a\in[K]}p_{t}(a)-\alpha\sum_{a\in[K]}p_{t}(a)\,c_{t}(a)+\beta\sum_{a\in[K]}p_{t}(a)\,c_{t}(a)^{2} \displaystyle=1-\alpha F_{t}+\beta G_{t}, \tag{80}
$$
where
$$
\displaystyle F_{t} \displaystyle=\sum_{a\in[K]}p_{t}(a)\cdot c_{t}(a)=\operatornamewithlimits{\mathbb{E}}\left[\,c_{t}(a_{t})\mid\vec{w}_{t}\,\right] \displaystyle G_{t} \displaystyle=\sum_{a\in[K]}p_{t}(a)\cdot c_{t}^{2}(a)=\operatornamewithlimits{\mathbb{E}}\left[\,c_{t}^{2}(a_{t})\mid\vec{w}_{t}\,\right]. \tag{81}
$$
Here $\vec{w}_{t}=\left(w_{t}(a):aâ[K]\right)$ is the vector of weights at round $t$ . Notice that the total expected cost of the algorithm is $\operatornamewithlimits{\mathbb{E}}[\mathtt{cost}(\mathtt{ALG})]=\sum_{t}\operatornamewithlimits{\mathbb{E}}[F_{t}]$ .
A naive attempt
Using the (80), we can obtain:
$$
\frac{(1-\epsilon)^{\mathtt{cost}^{*}}}{K}\leq\frac{W_{T+1}}{W_{1}}=\prod_{t=1}^{T}\frac{W_{t+1}}{W_{t}}<\prod_{t=1}^{T}(1-\alpha F_{t}+\beta G_{t}).
$$
However, it is unclear how to connect the right-hand side to $\sum_{t}F_{t}$ so as to argue about $\mathtt{cost}(\mathtt{ALG})$ .
Step 3: the telescoping product
Taking a logarithm on both sides of Eq. (80)) and using Eq. (75)), we obtain
$$
\ln\frac{W_{t+1}}{W_{t}}<\ln(1-\alpha F_{t}+\beta G_{t})<-\alpha F_{t}+\beta G_{t}.
$$
Inverting the signs and summing over $t$ on both sides, we obtain
$$
\displaystyle\sum_{t\in[T]}(\alpha F_{t}-\beta G_{t}) \displaystyle<-\sum_{t\in[T]}\ln\frac{W_{t+1}}{W_{t}} \displaystyle=-\ln\prod_{t\in[T]}\frac{W_{t+1}}{W_{t}} \displaystyle=-\ln\frac{W_{T+1}}{W_{1}} \displaystyle=\ln W_{1}-\ln W_{T+1} \displaystyle<\ln K-\ln(1-\epsilon)\cdot\text{cost}^{*}, \tag{82}
$$
where we used (78) in the last step. Taking expectation on both sides, we obtain:
$$
\displaystyle\alpha\cdot\operatornamewithlimits{\mathbb{E}}[\mathtt{cost}(\mathtt{ALG})]<\beta\sum_{t\in[T]}\operatornamewithlimits{\mathbb{E}}[G_{t}]+\ln{K}-\ln(1-\epsilon)\cdot\operatornamewithlimits{\mathbb{E}}[\mathtt{cost}^{*}]. \tag{83}
$$
We use this equation in two different ways, depending on the variant of Eq. (79). With $\alpha=\epsilon$ and $\beta=0$ and $c_{t}(·)†1$ , we obtain:
| | $\displaystyle\operatornamewithlimits{\mathbb{E}}[\mathtt{cost}(\mathtt{ALG})]<\tfrac{\ln{K}}{\epsilon}+\underbrace{\tfrac{1}{\epsilon}\ln(\tfrac{1}{1-\epsilon})}_{\text{$†1+\epsilon$ if $\epsilonâ(0,\nicefrac{{1}}{{2}})$}}\operatornamewithlimits{\mathbb{E}}[\mathtt{cost}^{*}].$ | |
| --- | --- | --- |
This yields the main regret bound for $\mathtt{Hedge}$ :
**Theorem 5.14**
*Assume all costs are at most $1$ . Consider an adaptive adversary such that $\mathtt{cost}^{*}†uT$ for some known number $u$ ; trivially, $u=1$ . Then $\mathtt{Hedge}$ with parameter $\epsilon=\sqrt{\tfrac{\ln K}{uT}}$ satisfies
$$
\operatornamewithlimits{\mathbb{E}}[\mathtt{cost}(\mathtt{ALG})-\mathtt{cost}^{*}]<2\cdot\sqrt{uT\ln{K}}.
$$*
**Remark 5.15**
*We also obtain a meaningful performance guarantee which holds with probability $1$ , rather than in expectation. Using the same parameters, $\alpha=\epsilon=\sqrt{\tfrac{\ln K}{T}}$ and $\beta=0$ , and assuming all costs are at most $1$ , Eq. (82) implies that
$$
\displaystyle\textstyle\sum_{t\in[T]}p_{t}\cdot c_{t}-\mathtt{cost}^{*}<2\cdot\sqrt{T\ln{K}}. \tag{84}
$$*
Step 4: unbounded costs
Next, we consider the case where the costs can be unbounded, but we have an upper bound on $\operatornamewithlimits{\mathbb{E}}[G_{t}]$ . We use Eq. (83) with $\alpha=\ln(\frac{1}{1-\epsilon})$ and $\beta=\alpha^{2}$ to obtain:
| | $\displaystyle\alpha\operatornamewithlimits{\mathbb{E}}[\mathtt{cost}(\mathtt{ALG})]<\alpha^{2}\sum_{tâ[T]}\operatornamewithlimits{\mathbb{E}}[G_{t}]+\ln{K}+\alpha\operatornamewithlimits{\mathbb{E}}[\mathtt{cost}^{*}].$ | |
| --- | --- | --- |
Dividing both sides by $\alpha$ and moving terms around, we get
$$
\operatornamewithlimits{\mathbb{E}}[\mathtt{cost}(\mathtt{ALG})-\mathtt{cost}^{*}]<\frac{\ln{K}}{\alpha}+\alpha\sum_{t\in[T]}\operatornamewithlimits{\mathbb{E}}[G_{t}]<\frac{\ln{K}}{\epsilon}+3\epsilon\sum_{t\in[T]}\operatornamewithlimits{\mathbb{E}}[G_{t}],
$$
where the last step uses the fact that $\epsilon<\alpha<3\epsilon$ for $\epsilonâ(0,\nicefrac{{1}}{{2}})$ . Thus:
**Theorem 5.16**
*Assume $\sum_{tâ[T]}\;\operatornamewithlimits{\mathbb{E}}[G_{t}]†uT$ for some known number $u$ , where $\operatornamewithlimits{\mathbb{E}}[G_{t}]=\operatornamewithlimits{\mathbb{E}}\left[\,c_{t}^{2}(a_{t})\,\right]$ as per (81). Then $\mathtt{Hedge}$ with parameter $\epsilon=\sqrt{\frac{\ln K}{3uT}}$ achieves regret
$$
\operatornamewithlimits{\mathbb{E}}[\mathtt{cost}(\mathtt{ALG})-\mathtt{cost}^{*}]<2\sqrt{3}\cdot\sqrt{uT\ln{K}}.
$$
In particular, if $c_{t}(·)†c$ , for some known $c$ , then one can take $u=c^{2}$ .*
In the next chapter we use this lemma to analyze a bandit algorithm.
Step 5: unbounded costs with small expectation and variance
Consider a randomized, oblivious adversary such that the costs are independent across rounds. Instead of bounding the actual costs $c_{t}(a)$ , let us instead bound their expectation and variance:
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}\left[\,c_{t}(a)\,\right]\leq\mu\text{ and }\text{Var}\left[\,c_{t}(a)\,\right]\leq\sigma^{2}\text{ for all rounds $t$ and all arms $a$}. \tag{85}
$$
Then for each round $t$ we have:
| | $\displaystyle\operatornamewithlimits{\mathbb{E}}\left[\,c_{t}(a)^{2}\,\right]$ | $\displaystyle=\text{Var}\left[\,c_{t}(a)\,\right]+\left(\,\operatornamewithlimits{\mathbb{E}}[c_{t}(a)]\,\right)^{2}â€\sigma^{2}+\mu^{2}.$ | |
| --- | --- | --- | --- |
Thus, Theorem 5.16 with $u=\mu^{2}+\sigma^{2}$ implies the following:
**Corollary 5.17**
*Consider online learning with experts, with a randomized, oblivious adversary. Assume the costs are independent across rounds, and satisfy (85) for some $\mu$ and $\sigma$ known to the algorithm. Then $\mathtt{Hedge}$ with parameter $\epsilon=\sqrt{\ln{K}/(3T(\mu^{2}+\sigma^{2}))}$ has regret
$$
\operatornamewithlimits{\mathbb{E}}[\mathtt{cost}(\mathtt{ALG})-\mathtt{cost}^{*}]<2\sqrt{3}\cdot\sqrt{T(\mu^{2}+\sigma^{2})\ln{K}}.
$$*
28 Literature review and discussion
The weighted majority algorithm is from Littlestone and Warmuth (1994), and $\mathtt{Hedge}$ algorithm is from (Littlestone and Warmuth, 1994; Cesa-Bianchi et al., 1997; Freund and Schapire, 1997). Freund and Schapire (1997) handles the full generality of online learning with experts. Littlestone and Warmuth (1994) and Cesa-Bianchi et al. (1997) focus on binary prediction with experts advice, with slightly stronger guarantees. Sequential prediction with experts advise has a long history in economics and statistics, see Cesa-Bianchi and Lugosi (2006, Chapter 2) for deeper discussion and bibliographic notes.
The material in this chapter is presented in many courses and books on online learning. This chapter mostly follows the lecture plan from (Kleinberg, 2007, Week 1), but presents the analysis of $\mathtt{Hedge}$ a little differently, so as to make it immediately applicable to the analysis of $\mathtt{Exp3}$ and $\mathtt{Exp4}$ in the next chapter.
The problem of online learning with experts, and $\mathtt{Hedge}$ algorithm for this problem, are foundational in a very strong sense. $\mathtt{Hedge}$ serves as a subroutine in adversarial bandits (Chapter 6) and bandits with global constraints (Chapter 10). The multiplicative-weights technique is essential in several extensions of adversarial bandits, e.g., the ones in Auer et al. (2002b) and Beygelzimer et al. (2011). $\mathtt{Hedge}$ also powers many applications âoutsideâ of multi-armed bandits or online machine learning, particularly in the design of primal-dual algorithms (see Arora et al. (2012) for a survey) and via the âlearning in gamesâ framework (see Chapter 9 and bibliographic remarks therein). In many of these applications, $\mathtt{Hedge}$ can be replaced by any algorithm for online learning with experts, as long as it satisfies an appropriate regret bound.
While the regret bound for $\mathtt{Hedge}$ comes with a fairly small constant, it is still a multiplicative constant away from the best known lower bound. Sometimes one can obtain upper and lower bounds on regret that match exactly. This has been accomplished for $K=2$ experts (Cover, 1965; Gravin et al., 2016) and for $K†3$ experts with a geometric time horizon That is, the game stops in each round independently with probability $\delta$ . (Gravin et al., 2016), along with an explicit specification of the optimal algorithm. Focusing on the regret of $\mathtt{Hedge}$ , Gravin et al. (2017) derived an improved the lower bound for each $K$ , exactly matching a known upper bound from Cesa-Bianchi et al. (1997).
Various stronger notions of regret have been studied; we detail them in the next chapter (Section 35).
Online learning with $K$ experts can be interpreted as one with action set $\Delta_{K}$ , the set of all distributions over the $K$ experts. This is a special case of online linear optimization (OLO) with a convex action set (see Chapter 7). In fact, $\mathtt{Hedge}$ can be interpreted as a special case of two broad families of algorithms for OLO, follow the regularized leader and online mirror descent; for background, see e.g., Hazan (2015) and McMahan (2017). This OLO-based perspective has been essential in much of the recent progress.
29 Exercises and hints
**Exercise 5.1**
*Consider binary prediction with expert advice, with a perfect expert. Prove Theorem 5.8: prove that any algorithm makes at least $\Omega(\min(T,\log K))$ mistakes in the worst case. Take-away: The majority vote algorithm is worst-case-optimal for instances with a perfect expert. Hint: For simplicity, let $K=2^{d}$ and $Tâ„ d$ , for some integer $d$ . Construct a distribution over problem instances such that each algorithm makes $\Omega(d)$ mistakes in expectation. Recall that each expert $e$ corresponds to a binary sequence $eâ\{0,1\}^{T}$ , where $e_{t}$ is the prediction for round $t$ . Put experts in 1-1 correspondence with all possible binary sequences for the first $d$ rounds. Pick the âperfect expertâ u.a.r. among the experts.*
**Exercise 5.2 (IID costs and regret)**
*Assume IID costs, as in Remark 5.3.
- Prove that $\min_{a}\operatornamewithlimits{\mathbb{E}}[\mathtt{cost}(a)]â€\operatornamewithlimits{\mathbb{E}}[\min_{a}\mathtt{cost}(a)]+O(\sqrt{T\log(KT)})$ .
Take-away: All $\sqrt{T}$ -regret bounds from Chapter 1 carry over to regret.
Hint: Define the âclean eventâ as follows: the event in Hoeffding inequality holds for the cost sequence of each arm.
- Construct a problem instance with a deterministic adversary for which any algorithm suffers regret
| | $\displaystyle\operatornamewithlimits{\mathbb{E}}[\mathtt{cost}(\mathtt{ALG})-\min_{aâ[K]}\mathtt{cost}(a)]â„\Omega(\sqrt{T\,\log K}).$ | |
| --- | --- | --- |
Hint: Assume all arms have 0-1 costs with mean $\nicefrac{{1}}{{2}}$ . Use the following fact about random walks:
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}[\min_{a}\mathtt{cost}(a)]\leq\tfrac{T}{2}-\Omega(\sqrt{T\,\log K}). \tag{86}
$$
Note: This example does not carry over to pseudo-regret. Since each arm has expected reward of $\nicefrac{{1}}{{2}}$ in each round, any algorithm trivially achieves $0$ pseudo-regret for this problem instance.
Take-away: The $O(\sqrt{T\log K})$ regret bound for $\mathtt{Hedge}$ is the best possible for regret. Further, $\log(T)$ upper regret bounds from Chapter 1 do not carry over to regret in full generality.
- Prove that algorithms $\mathtt{UCB}$ and Successive Elimination achieve logarithmic regret bound (11) even for regret, assuming that the best-in-foresight arm $a^{*}$ is unique.
Hint: Under the âclean eventâ, $\mathtt{cost}(a)<T·\mu(a)+O(\sqrt{T\log T})$ for each arm $aâ a^{*}$ , where $\mu(a)$ is the mean cost. It follows that $a^{*}$ is also the best-in-hindsight arm, unless $\mu(a)-\mu(a^{*})<O(\sqrt{T\log T})$ for some arm $aâ a^{*}$ (in which case the claimed regret bound holds trivially).*
**Exercise 5.3**
*Prove Theorem 5.11: prove that any deterministic algorithm for the online learning problem with $K$ experts and 0-1 costs can suffer total cost $T$ for some deterministic-oblivious adversary, even if $\mathtt{cost}^{*}†T/K$ . Take-away: With a deterministic algorithm, cannot even recover the guarantee from Theorem 5.9 for the general case of online learning with experts, let alone have $o(T)$ regret. Hint: Fix the algorithm. Construct the problem instance by induction on round $t$ , so that the chosen arm has cost $1$ and all other arms have cost $0$ .*
Chapter 6 Adversarial Bandits
This chapter is concerned with adversarial bandits: multi-armed bandits with adversarially chosen costs. In fact, we solve a more general formulation that explicitly includes expert advice. Our algorithm is based on a reduction to the full-feedback problem studied in Chapter 5.
Prerequisites: Chapter 5.
For ease of exposition, we focus on deterministic, oblivious adversary: that is, the costs for all arms and all rounds are chosen in advance. We are interested in regret with respect to the best-in-hindsight arm, as defined in Eq. (73). We assume bounded per-round costs: $c_{t}(a)†1$ for all rounds $t$ and all arms $a$ .
We achieve regret bound $\operatornamewithlimits{\mathbb{E}}[R(T)]†O\left(\sqrt{KT\log K}\right)$ . Curiously, this upper regret bound not only matches our result for IID bandits (Theorem 1.10), but in fact improves it a little bit, replacing the $\log T$ with $\log K$ . This regret bound is essentially optimal, due to the $\Omega(\sqrt{KT})$ lower bound from Chapter 2.
Recap from Chapter 5
Let us recap the material on the full-feedback problem, reframing it slightly for this chapter. Recall that in the full-feedback problem, the cost of each arm is revealed after every round. A common interpretation is that each action corresponds to an âexpertâ that gives advice or makes predictions, and in each round the algorithm needs to choose which expert to follow. Hence, this problem is also known as the online learning with experts. We considered a particular algorithm for this problem, called $\mathtt{Hedge}$ . In each round $t$ , it computes a distribution $p_{t}$ over experts, and samples an expert from this distribution. We obtained the following regret bound (Theorem 5.16):
**Theorem 6.1**
*Consider online learning with $N$ experts and $T$ rounds. Consider an adaptive adversary and regret $R(T)$ relative to the best-observed expert. Suppose in any run of $\mathtt{Hedge}$ , with any parameter $\epsilon>0$ , it holds that $\sum_{tâ[T]}\;\operatornamewithlimits{\mathbb{E}}[G_{t}]†uT$ for some known $u>0$ , where $G_{t}=\sum_{\text{experts $e$}}p_{t}(e)\;c_{t}^{2}(e)$ . Then
$$
\operatornamewithlimits{\mathbb{E}}[R(T)]\leq 2\sqrt{3}\cdot\sqrt{uT\log N}\qquad\text{provided that}\quad\epsilon=\epsilon_{u}:=\sqrt{\tfrac{\ln N}{3uT}}.
$$*
We will distinguish between âexpertsâ in the full-feedback problem and âactionsâ in the bandit problem. Therefore, we will consistently use âexpertsâ for the former and âactions/armsâ for the latter.
30 Reduction from bandit feedback to full feedback
Our algorithm for adversarial bandits is a reduction to the full-feedback setting. The reduction proceeds as follows. For each arm, we create an expert which always recommends this arm. We use $\mathtt{Hedge}$ with this set of experts. In each round $t$ , we use the expert $e_{t}$ chosen by $\mathtt{Hedge}$ to pick an arm $a_{t}$ , and define âfake costsâ $\widehat{c}_{t}(·)$ on all experts in order to provide $\mathtt{Hedge}$ with valid inputs. This generic reduction is given below:
Given: set $\mathcal{E}$ of experts, parameter $\epsilonâ(0,\tfrac{1}{2})$ for $\mathtt{Hedge}$ .
In each round $t$ ,
1. Call $\mathtt{Hedge}$ , receive the probability distribution $p_{t}$ over $\mathcal{E}$ .
1. Draw an expert $e_{t}$ independently from $p_{t}$ .
1. Selection rule: use $e_{t}$ to pick arm $a_{t}$ (TBD).
1. Observe the cost $c_{t}(a_{t})$ of the chosen arm.
1. Define âfake costsâ $\widehat{c}_{t}(e)$ for all experts $xâ\mathcal{E}$ (TBD).
1. Return the âfake costsâ to $\mathtt{Hedge}$ .
Algorithm 1 Reduction from bandit feedback to full feedback
We will specify how to select arm $a_{t}$ using expert $e_{t}$ , and how to define fake costs. The former provides for sufficient exploration, and the latter ensures that fake costs are unbiased estimates of the true costs.
31 Adversarial bandits with expert advice
The reduction defined above suggests a more general problem: what if experts can predict different arms in different rounds? This problem, called bandits with expert advice, is one that we will actually solve. We do it for three reasons: because it is a very interesting generalization, because we can solve it with very little extra work, and because separating experts from actions makes the solution clearer. Formally, the problem is defined as follows:
Problem protocol: Adversarial bandits with expert advice
Given: $K$ arms, set $\mathcal{E}$ of $N$ experts, $T$ rounds (all known). In each round $tâ[T]$ :
- adversary picks cost $c_{t}(a)â„ 0$ for each arm $aâ[K]$ ,
- each expert $eâ\mathcal{E}$ recommends an arm $a_{t,e}$ (observed by the algorithm),
- algorithm picks arm $a_{t}â[K]$ and receives the corresponding cost $c_{t}(a_{t})$ .
The total cost of each expert is defined as $\mathtt{cost}(e)=\sum_{tâ[T]}c_{t}(a_{t,e})$ . The goal is to minimize regret relative to the best expert, rather than the best action:
$$
R(T)=\mathtt{cost}(\text{$\mathtt{ALG}$})-\min_{e\in\mathcal{E}}{\mathtt{cost}(e)}.
$$
We focus on a deterministic, oblivious adversary: all costs $c_{t}(·)$ are selected in advance. Further, we assume that the recommendations $a_{t,e}$ are also chosen in advance, i.e., the experts cannot learn over time.
We solve this problem via the reduction in Algorithm 1, and achieve
$$
\operatornamewithlimits{\mathbb{E}}[R(T)]\leq O\left(\,\sqrt{KT\log N}\,\right).
$$
Note the logarithmic dependence on $N$ : this regret bound allows to handle lots of experts.
This regret bound is essentially the best possible. Specifically, there is a nearly matching lower bound on regret that holds for any given triple of parameters $K,T,N$ :
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}[R(T)]\geq\min\left(\,T,\;\Omega\left(\,\sqrt{KT\log(N)/\log(K)}\,\right)\,\right). \tag{87}
$$
This lower bound can be proved by an ingenious (yet simple) reduction to the basic $\Omega(\sqrt{KT})$ lower regret bound for bandits, see Exercise 6.1.
32 Preliminary analysis: unbiased estimates
We have two notions of âcostâ on experts. For each expert $e$ at round $t$ , we have the true cost $c_{t}(e)=c_{t}(a_{t,e})$ determined by the predicted arm $a_{t,e}$ , and the fake cost $\widehat{c}_{t}(e)$ that is computed inside the algorithm and then fed to $\mathtt{Hedge}$ . Thus, our regret bounds for $\mathtt{Hedge}$ refer to the fake regret defined relative to the fake costs:
$$
\widehat{R}_{\mathtt{Hedge}}(T)=\widehat{\mathtt{cost}}(\mathtt{Hedge})-\min_{e\in\mathcal{E}}\widehat{\mathtt{cost}}(e),
$$
where $\widehat{\mathtt{cost}}(\mathtt{Hedge})$ and $\widehat{\mathtt{cost}}(e)$ are the total fake costs for $\mathtt{Hedge}$ and expert $e$ , respectively.
We want the fake costs to be unbiased estimates of the true costs. This is because we will need to convert a bound on the fake regret $\widehat{R}_{\mathtt{Hedge}}(T)$ into a statement about the true costs accumulated by $\mathtt{Hedge}$ . Formally, we ensure that
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}\left[\,\widehat{c}_{t}(e)\mid\vec{p}_{t}\,\right]=c_{t}(e)\quad\text{for all experts $e$}, \tag{88}
$$
where $\vec{p}_{t}=(p_{t}(e):\;\text{all experts $e$})$ . We use this as follows:
**Claim 6.2**
*Assuming Eq. (88), it holds that $\operatornamewithlimits{\mathbb{E}}[R_{\mathtt{Hedge}}(T)]â€\operatornamewithlimits{\mathbb{E}}[\widehat{R}_{\mathtt{Hedge}}(T)]$ .*
* Proof*
First, we connect true costs of $\mathtt{Hedge}$ with the corresponding fake costs.
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}\left[\,\widehat{c}_{t}(e_{t})\mid\vec{p}_{t}\,\right] \displaystyle=\textstyle\sum_{e\in\mathcal{E}}\Pr\left[\,e_{t}=e\mid\vec{p}_{t}\,\right]\;\operatornamewithlimits{\mathbb{E}}\left[\,\widehat{c}_{t}(e)\mid\vec{p}_{t}\,\right] \displaystyle=\textstyle\sum_{e\in\mathcal{E}}p_{t}(e)\;c_{t}(e) \displaystyle=\operatornamewithlimits{\mathbb{E}}\left[\,c_{t}(e_{t})\mid\vec{p}_{t}\,\right]. \tag{88}
$$
Taking expectation of both sides, $\operatornamewithlimits{\mathbb{E}}[\widehat{c}_{t}(e_{t})]=\operatornamewithlimits{\mathbb{E}}[c_{t}(e_{t})]$ . Summing over all rounds, it follows that
| | $\displaystyle\operatornamewithlimits{\mathbb{E}}\left[\,\widehat{\mathtt{cost}}(\mathtt{Hedge})\,\right]=\operatornamewithlimits{\mathbb{E}}\left[\,\mathtt{cost}(\mathtt{Hedge})\,\right].$ | |
| --- | --- | --- | To complete the proof, we deal with the benchmark:
$$
\operatornamewithlimits{\mathbb{E}}\left[\,\min_{e\in\mathcal{E}}\widehat{\mathtt{cost}}(e)\,\right]\leq\min_{e\in\mathcal{E}}\operatornamewithlimits{\mathbb{E}}\left[\,\widehat{\mathtt{cost}}(e)\,\right]=\min_{e\in\mathcal{E}}\operatornamewithlimits{\mathbb{E}}\left[\,\mathtt{cost}(e)\,\right]=\min_{e\in\mathcal{E}}\mathtt{cost}(e).
$$
The first equality holds by (88), and the second equality holds because true costs $c_{t}(e)$ are deterministic. â
**Remark 6.3**
*This proof used the âfull powerâ of assumption (88). A weaker assumption $\operatornamewithlimits{\mathbb{E}}\left[\,\widehat{c}_{t}(e)\,\right]=\operatornamewithlimits{\mathbb{E}}[c_{t}(e)]$ would not have sufficed to argue about true vs. fake costs of $\mathtt{Hedge}$ .*
33 Algorithm $\mathtt{Exp4}$ and crude analysis
To complete the specification of Algorithm 1, we need to define fake costs $\widehat{c}_{t}(·)$ and specify how to choose an arm $a_{t}$ . For fake costs, we will use a standard trick in statistics called Inverse Propensity Score (IPS). Whichever way arm $a_{t}$ is chosen in each round $t$ given the probability distribution $\vec{p}_{t}$ over experts, this defines distribution $q_{t}$ over arms:
$$
q_{t}(a):=\Pr\left[\,a_{t}=a\mid\vec{p}_{t}\,\right]\quad\text{for each arm $a$}.
$$
Using these probabilities, we define the fake costs on each arm as follows:
$$
\widehat{c}_{t}(a)=\left\{\begin{array}[]{ll}c_{t}(a_{t})/q_{t}(a_{t})&\quad a_{t}=a,\\
0&\quad\text{otherwise}.\end{array}\right.
$$
The fake cost on each expert $e$ is defined as the fake cost of the arm chosen by this expert: $\widehat{c}_{t}(e)=\widehat{c}_{t}(a_{t,e})$ .
**Remark 6.4**
*Algorithm 1 can use fake costs as defined above as long as it can compute probability $q_{t}(a_{t})$ .*
**Claim 6.5**
*Eq. (88) holds if $q_{t}(a_{t,e})>0$ for each expert $e$ .*
* Proof*
Let us argue about each arm $a$ separately. If $q_{t}(a)>0$ then
$$
\operatornamewithlimits{\mathbb{E}}\left[\,\widehat{c}_{t}(a)\mid\vec{p}_{t}\,\right]=\Pr\left[\,a_{t}=a\mid\vec{p}_{t}\,\right]\cdot\frac{c_{t}(a_{t})}{q_{t}(a)}+\Pr\left[\,a_{t}\neq a\mid\vec{p}_{t}\,\right]\cdot 0=c_{t}(a).
$$
For a given expert $e$ plug in arm $a=a_{t,e}$ , its choice in round $t$ . â
So, if an arm $a$ is selected by some expert in a given round $t$ , the selection rule needs to choose this arm with non-zero probability, regardless of which expert is actually chosen by $\mathtt{Hedge}$ and what is this expertâs recommendation. Further, if probability $q_{t}(a)$ is sufficiently large, then one can upper-bound fake costs and apply Theorem 6.1. On the other hand, we would like to follow the chosen expert $e_{t}$ most of the time, so as to ensure low costs. A simple and natural way to achieve both objectives is to follow $e_{t}$ with probability $1-\gamma$ , for some small $\gamma>0$ , and with the remaining probability choose an arm uniformly at random. This completes the specification of our algorithm, which is known as $\mathtt{Exp4}$ . We recap it in Algorithm 2.
Given: set $\mathcal{E}$ of experts, parameter $\epsilonâ(0,\tfrac{1}{2})$ for $\mathtt{Hedge}$ , exploration parameter $\gammaâ[0,\tfrac{1}{2})$ .
In each round $t$ ,
1. Call $\mathtt{Hedge}$ , receive the probability distribution $p_{t}$ over $\mathcal{E}$ .
1. Draw an expert $e_{t}$ independently from $p_{t}$ .
1. Selection rule: with probability $1-\gamma$ follow expert $e_{t}$ ; else pick an arm $a_{t}$ uniformly at random.
1. Observe the cost $c_{t}(a_{t})$ of the chosen arm.
1. Define fake costs for all experts $e$ :
$$
\widehat{c}_{t}(e)=\left\{\begin{array}[]{ll}\frac{c_{t}(a_{t})}{\Pr[a_{t}=a_{t,e}\mid\vec{p}_{t}]}&\quad a_{t}=a_{t,e},\\
0&\quad\text{otherwise}.\end{array}\right.
$$
1. Return the âfake costsâ $\widehat{c}(·)$ to $\mathtt{Hedge}$ .
Algorithm 2 Algorithm $\mathtt{Exp4}$ for adversarial bandits with experts advice
Note that $q_{t}(a)â„\gamma/K>0$ for each arm $a$ . According to Claim 6.5 and Claim 6.2, the expected true regret of $\mathtt{Hedge}$ is upper-bounded by its expected fake regret: $\operatornamewithlimits{\mathbb{E}}[R_{\mathtt{Hedge}}(T)]â€\operatornamewithlimits{\mathbb{E}}[\widehat{R}_{\mathtt{Hedge}}(T)]$ .
**Remark 6.6**
*Fake costs $\widehat{c}_{t}(·)$ depend on the probability distribution $\hat{p}_{t}$ chosen by $\mathtt{Hedge}$ . This distribution depends on the actions selected by $\mathtt{Exp4}$ in the past, and these actions in turn depend on the experts chosen by $\mathtt{Hedge}$ in the past. To summarize, fake costs depend on the experts chosen by $\mathtt{Hedge}$ in the past. So, fake costs do not form an oblivious adversary, as far as $\mathtt{Hedge}$ is concerned. Thus, we need regret guarantees for $\mathtt{Hedge}$ against an adaptive adversary, even though the true costs are chosen by an oblivious adversary.*
In each round $t$ , our algorithm accumulates cost at most $1$ from the low-probability exploration, and cost $c_{t}(e_{t})$ from the chosen expert $e_{t}$ . So the expected cost in this round is $\operatornamewithlimits{\mathbb{E}}[c_{t}(a_{t})]â€\gamma+\operatornamewithlimits{\mathbb{E}}[c_{t}(e_{t})]$ . Summing over all rounds, we obtain:
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}\left[\,\mathtt{cost}(\mathtt{Exp4})\,\right] \displaystyle\leq\operatornamewithlimits{\mathbb{E}}\left[\,\mathtt{cost}(\mathtt{Hedge})\,\right]+\gamma T. \displaystyle\operatornamewithlimits{\mathbb{E}}\left[\,R_{\mathtt{Exp4}}(T)\,\right] \displaystyle\leq\operatornamewithlimits{\mathbb{E}}\left[\,R_{\mathtt{Hedge}}(T)\,\right]+\gamma T\leq\operatornamewithlimits{\mathbb{E}}\left[\,\widehat{R}_{\mathtt{Hedge}}(T)\,\right]+\gamma T. \tag{89}
$$
Eq. (89) quantifies the sense in which the regret bound for $\mathtt{Exp4}$ reduces to the regret bound for $\mathtt{Hedge}$ .
We can immediately derive a crude regret bound via Theorem 6.1. Observing $\widehat{c}_{t}(a)†1/q_{t}(a)†K/\gamma$ , we can take $u=(K/\gamma)^{2}$ in the theorem, and conclude that
$$
\operatornamewithlimits{\mathbb{E}}\left[\,R_{\mathtt{Exp4}}(T)\,\right]\leq O\left(\,\nicefrac{{K}}{{\gamma}}\cdot K^{1/2}\;(\log N)^{1/4}+\gamma T\,\right).
$$
To (approximately) minimize expected regret, choose $\gamma$ so as to equalize the two summands.
**Theorem 6.7**
*Consider adversarial bandits with expert advice, with a deterministic-oblivious adversary. Algorithm $\mathtt{Exp4}$ with parameters $\gamma=T^{-1/4}\;K^{1/2}\;(\log N)^{1/4}$ and $\epsilon=\epsilon_{u}$ , $u=K/\gamma$ , achieves regret
$$
\operatornamewithlimits{\mathbb{E}}\left[\,R(T)\,\right]=O\left(\,T^{3/4}\;K^{1/2}\;(\log N)^{1/4}\,\right).
$$*
**Remark 6.8**
*We did not use any property of $\mathtt{Hedge}$ other than the regret bound in Theorem 6.1. Therefore, $\mathtt{Hedge}$ can be replaced with any other full-feedback algorithm with the same regret bound.*
34 Improved analysis of $\mathtt{Exp4}$
We obtain a better regret bound by analyzing the quantity
$$
\textstyle\widehat{G}_{t}:=\sum_{e\in\mathcal{E}}p_{t}(e)\;\widehat{c}_{t}^{2}(e).
$$
We prove that $\operatornamewithlimits{\mathbb{E}}[G_{t}]â€\tfrac{K}{1-\gamma}$ , and use the regret bound for $\mathtt{Hedge}$ , Theorem 6.1, with $u=\tfrac{K}{1-\gamma}$ . In contrast, the crude analysis presented above used Theorem 6.1 with $u=(\nicefrac{{K}}{{\gamma}})^{2}$ .
**Remark 6.9**
*This analysis extends to $\gamma=0$ . In other words, the uniform exploration step in the algorithm is not necessary. While we previously used $\gamma>0$ to guarantee that $q_{t}(a_{t,e})>0$ for each expert $e$ , the same conclusion also follows from the fact that $\mathtt{Hedge}$ chooses each expert with a non-zero probability.*
**Lemma 6.10**
*Fix parameter $\gammaâ[0,\tfrac{1}{2})$ and round $t$ . Then $\operatornamewithlimits{\mathbb{E}}[\widehat{G}_{t}]â€\tfrac{K}{1-\gamma}$ .*
* Proof*
For each arm $a$ , let $\mathcal{E}_{a}=\{eâ\mathcal{E}:a_{t,e}=a\}$ be the set of all experts that recommended this arm. Let p_t(a) := â_e â E _a p_t(e) be the probability that the expert chosen by $\mathtt{Hedge}$ recommends arm $a$ . Then
$$
q_{t}(a)=p_{t}(a)(1-\gamma)+\frac{\gamma}{K}\geq(1-\gamma)\;p_{t}(a).
$$
For each expert $e$ , letting $a=a_{t,e}$ be the recommended arm, we have:
$$
\displaystyle\widehat{c}_{t}(e)=\widehat{c}_{t}(a)\leq\frac{c_{t}(a)}{q_{t}(a)}\leq\frac{1}{q_{t}(a)}\leq\frac{1}{(1-\gamma)\;p_{t}(a)}. \tag{90}
$$
Each realization of $\widehat{G}_{t}$ satisfies:
$$
\displaystyle\widehat{G}_{t} \displaystyle:=\sum_{e\in\mathcal{E}}p_{t}(e)\;\widehat{c}_{t}^{2}(e) \displaystyle=\sum\limits_{a}\sum\limits_{e\in\mathcal{E}_{a}}p_{t}(e)\cdot\widehat{c}_{t}(e)\cdot\widehat{c}_{t}(e) \displaystyle\leq\sum\limits_{a}\sum\limits_{e\in\mathcal{E}_{a}}\frac{p_{t}(e)}{(1-\gamma)\;p_{t}(a)}\;\widehat{c}_{t}(a) \displaystyle=\frac{1}{1-\gamma}\;\sum\limits_{a}\frac{\widehat{c}_{t}(a)}{p_{t}(a)}\sum\limits_{e\in\mathcal{E}_{a}}p_{t}(e) \displaystyle=\frac{1}{1-\gamma}\;\sum\limits_{a}\widehat{c}_{t}(a) \tag{90}
$$
To complete the proof, take expectations over both sides and recall that $\operatornamewithlimits{\mathbb{E}}[\widehat{c}_{t}(a)]=c_{t}(a)†1$ . â
Let us complete the analysis, being slightly careful with the multiplicative constant in the regret bound:
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}\left[\,\widehat{R}_{\mathtt{Hedge}}(T)\,\right] \displaystyle\leq 2\sqrt{3/(1-\gamma)}\cdot\sqrt{TK\log N} \displaystyle\operatornamewithlimits{\mathbb{E}}\left[\,R_{\mathtt{Exp4}}(T)\,\right] \displaystyle\leq 2\sqrt{3/(1-\gamma)}\cdot\sqrt{TK\log N}+\gamma T \displaystyle\leq 2\sqrt{3}\cdot\sqrt{TK\log N}+2\gamma T \tag{89}
$$
(To derive (91), we assumed w.l.o.g. that $2\sqrt{3}·\sqrt{TK\log N}†T$ .) This holds for any $\gamma>0$ . Therefore:
**Theorem 6.11**
*Consider adversarial bandits with expert advice, with a deterministic-oblivious adversary. Algorithm $\mathtt{Exp4}$ with parameters $\gammaâ[0,\tfrac{1}{2T})$ and $\epsilon=\epsilon_{U}$ , $U=\tfrac{K}{1-\gamma}$ , achieves regret
$$
\operatornamewithlimits{\mathbb{E}}[R(T)]\leq 2\sqrt{3}\cdot\sqrt{TK\log N}+1.
$$*
35 Literature review and discussion
$\mathtt{Exp4}$ stands for exp loration, exp loitation, exp onentiation, and exp erts. The specialization to adversarial bandits (without expert advice, i.e., with experts that correspond to arms) is called $\mathtt{Exp3}$ , for the same reason. Both algorithms were introduced (and named) in the seminal paper (Auer et al., 2002b), along with several extensions. Their analysis is presented in various books and courses on online learning (e.g., Cesa-Bianchi and Lugosi, 2006; Bubeck and Cesa-Bianchi, 2012). Our presentation was most influenced by (Kleinberg, 2007, Week 8), but the reduction to $\mathtt{Hedge}$ is made more explicit.
Apart from the stated regret bound, $\mathtt{Exp4}$ can be usefully applied in several extensions: contextual bandits (Chapter 8), shifting regret, and dynamic regret for slowly changing costs (both: see below).
The lower bound (87) for adversarial bandits with expert advice is due to Agarwal et al. (2012). We used a slightly simplified construction from Seldin and Lugosi (2016) in the hint for Exercise 6.1.
Running time. The running time of $\mathtt{Exp4}$ is $O(N+K)$ , so the algorithm becomes very slow when $N$ , the number of experts, is very large. Good regret and good running time can be obtained for some important special cases with a large $N$ . One approach is to replace $\mathtt{Hedge}$ with a different algorithm for online learning with experts which satisfies one or both regret bounds in Theorem 6.1. We follow this approach in the next chapter. On the other hand, the running time for $\mathtt{Exp3}$ is very nice because in each round, we only need to do a small amount of computation to update the weights.
35.1 Refinements for the âstandardâ notion of regret
Much research has been done on various refined guarantees for adversarial bandits, using the notion of regret defined in this chapter. The most immediate ones are as follows:
- an algorithm that obtains a similar regret bound for adaptive adversaries (against the best-observed arm), and high probability. This is Algorithm $\mathtt{EXP3.P.1}$ in the original paper Auer et al. (2002b).
- an algorithm with $O(\sqrt{KT})$ regret, shaving off the $\sqrt{\log K}$ factor and matching the lower bound up to constant factors (Audibert and Bubeck, 2010).
- While we have only considered a finite number of experts, similar results can be obtained for infinite classes of experts with some special structure. In particular, borrowing the tools from statistical learning theory, it is possible to handle classes of experts with a small VC-dimension.
Data-dependent regret bounds provide improvements if the realized costs are, in some sense, âniceâ, even though the extent of this ânicenessâ is not revealed to the algorithm. Such regret bounds come in many flavors, discussed below.
- Small benchmark: the total expected cost/reward of the best arm, denoted $B$ . The $\tilde{O}(\sqrt{KT})$ regret rate can be improved to $\tilde{O}(\sqrt{KB})$ , without knowing $B$ in advance. The reward-maximizing version, when small $B$ means that the best arm is that good, has been solved in the original paper (Auer et al., 2002b). In the cost-minimizing version, small $B$ has an opposite meaning: the best arm is quite good. This version, a.k.a. small-loss regret bounds, has been much more challenging (Allenberg et al., 2006; Rakhlin and Sridharan, 2013a; Neu, 2015; Foster et al., 2016b; Lykouris et al., 2018b).
- Small change in costs: one can obtain regret bounds that are near-optimal in the worst case, and improve when the realized cost of each arm $a$ does not change too much. Small change in costs can be quantified in terms of the total variation $\sum_{t,a}\left(\,c_{t}(a)-\mathtt{cost}(a)/T\,\right)^{2}$ (Hazan and Kale, 2011), or in terms of path-lengths $\sum_{t}|c_{t}(a)-c_{t-1}(a)|$ (Wei and Luo, 2018; Bubeck et al., 2019). However, these guarantees do not do much when only the change in expected costs is small, e.g., for IID costs.
- Best of both worlds: algorithms that work well for both adversarial and stochastic bandits. Bubeck and Slivkins (2012) achieve an algorithm that is near-optimal in the worst case (like $\mathtt{Exp3}$ ), and achieves logarithmic regret (like $\mathtt{UCB1}$ ) if the costs are actually IID Further work refines and optimizes the regret bounds, achieves them with a more practical algorithm, and improves them for the adversarial case if the adversary is constrained (Seldin and Slivkins, 2014; Auer and Chiang, 2016; Seldin and Lugosi, 2017; Wei and Luo, 2018; Zimmert et al., 2019; Zimmert and Seldin, 2019).
- Small change in expected costs. A particularly clean model unifies the themes of âsmall changeâ and âbest of both worldsâ discussed above. It focuses on the total change in expected costs, denoted $C$ and interpreted as an adversarial corruption of an otherwise stochastic problem instance. The goal here is regret bounds that are logarithmic when $C=0$ (i.e., for IID costs) and degrade gracefully as $C$ increases, even if $C$ is not known to the algorithm. Initiated in Lykouris et al. (2018a), this direction continued in (Gupta et al., 2019; Zimmert and Seldin, 2021) and a number of follow-ups.
35.2 Stronger notions of regret
Let us consider several benchmarks that are stronger than the best-in-hindsight arm in (73).
Shifting regret. One can compete with âpoliciesâ that can change the arm from one round to another, but not too often. More formally, an $S$ -shifting policy is sequence of arms $\pi=(a_{t}:tâ[T])$ with at most $S$ âshiftsâ: rounds $t$ such that $a_{t}â a_{t+1}$ . $S$ -shifting regret is defined as the algorithmâs total cost minus the total cost of the best $S$ -shifting policy:
$$
R_{S}(T)=\mathtt{cost}(\mathtt{ALG})-\min_{\text{$S$-shifting policies $\pi$}}\mathtt{cost}(\pi).
$$
Consider this as a bandit problem with expert advice, where each $S$ -shifting policy is an expert. The number of experts $Nâ€(KT)^{S}$ ; while it may be a large number, $\log(N)$ is not too bad! Using $\mathtt{Exp4}$ and plugging $Nâ€(KT)^{S}$ into Theorem 6.11, we obtain $\operatornamewithlimits{\mathbb{E}}[R_{S}(T)]=\tilde{O}(\sqrt{KST})$ .
While $\mathtt{Exp4}$ is computationally inefficient, Auer et al. (2002b) tackle shifting regret using a modification of $\mathtt{Exp3}$ algorithm, with essentially the same running time as $\mathtt{Exp3}$ and a more involved analysis. They obtain $\operatornamewithlimits{\mathbb{E}}[R_{S}(T)]=\tilde{O}(\sqrt{SKT})$ if $S$ is known, and $\operatornamewithlimits{\mathbb{E}}[R_{S}(T)]=\tilde{O}(S\sqrt{KT})$ if $S$ is not known.
For a fixed $S$ , any algorithm suffers regret $\Omega(\sqrt{SKT})$ in the worst case (Garivier and Moulines, 2011).
Dynamic regret. The strongest possible benchmark is the best current arm: $c^{*}_{t}=\min_{a}c_{t}(a)$ . We are interested in dynamic regret, defined as
$$
R^{*}(T)=\textstyle\min(\mathtt{ALG})-\sum_{t\in[T]}\;c^{*}_{t}.
$$
This benchmark is too hard in the worst case, without additional assumptions. In what follows, we consider a randomized oblivious adversary, and make assumptions on the rate of change in cost distributions.
Assume the adversary changes the cost distribution at most $S$ times. One can re-use results for shifting regret, so as to obtain expected dynamic regret $\tilde{O}(\sqrt{SKT})$ when $S$ is known, and $\tilde{O}(S\sqrt{KT})$ when $S$ is not known. The former regret bound is optimal (Garivier and Moulines, 2011). The regret bound for unknown $S$ can be improved to $\operatornamewithlimits{\mathbb{E}}[R^{*}(T)]=\tilde{O}(\sqrt{SKT})$ , matching the optimal regret rate for known $S$ , using more advanced algorithms (Auer et al., 2019; Chen et al., 2019).
Suppose expected costs change slowly, by at most $\epsilon$ in each round. Then one can obtain bounds on dynamic regret of the form $\operatornamewithlimits{\mathbb{E}}[R^{*}(T)]†C_{\epsilon,K}· T$ , where $C_{\epsilon,K}\ll 1$ is a âconstantâ determined by $\epsilon$ and $K$ . The intuition is that the algorithm pays a constant per-round âpriceâ for keeping up with the changing costs, and the goal is to minimize this price as a function of $K$ and $\epsilon$ . Stronger regret bound (i.e., one with smaller $C_{\epsilon,K}$ ) is possible if expected costs evolve as a random walk. Formally, the expected cost of each arm evolves as an independent random walk on $[0,1]$ interval with reflecting boundaries. One way to address these scenarios is to use an algorithm with $S$ -shifting regret, for an appropriately chosen value of $S$ , and restart it after a fixed number of rounds, e.g., see Exercise 6.3. Slivkins and Upfal (2008); Slivkins (2014) provide algorithms with better bounds on dynamic regret, and obtain matching lower bounds. Their approach is an extension of the $\mathtt{UCB1}$ algorithm, see Algorithm 5 in Chapter 1. In a nutshell, they add a term $\phi_{t}$ to the definition of $\mathtt{UCB}_{t}(·)$ , where $\phi_{t}$ is a known high-confidence upper bound on each armâs change in expected rewards in $t$ steps, and restart this algorithm every $n$ steps, for a suitably chosen fixed $n$ . E.g., $\phi_{t}=\epsilon t$ in general, and $\phi_{t}=O(\sqrt{t\log T})$ for the random walk scenario. In principle, $\phi_{t}$ can be arbitrary, possibly depending on an arm and on the time of the latest restart.
A more flexible model considers the total variation in cost distributions, $V=\sum_{tâ[T-1]}V_{t}$ , where $V_{t}$ is the amount of change in a given round $t$ (defined as a total-variation distance between the cost distribution for rounds $t$ and $t+1$ ). While $V$ can be as large as $KT$ in the worst case, the idea is to benefit when $V$ is small. Compared to the previous two models, an arbitrary amount of per-round change is allowed, and a larger amount of change is âweighedâ more heavily. The optimal regret rate is $\tilde{O}(V^{1/3}T^{2/3})$ when $V$ is known; it can be achieved, e.g., by $\mathtt{Exp4}$ algorithm with restarts. The same regret rate can be achieved even without knowing $V$ , using a more advanced algorithm (Chen et al., 2019). This result also obtains the best possible regret rate when each armâs expected costs change by at most $\epsilon$ per round, without knowing the $\epsilon$ . However, this approach does not appear to obtain better regret bounds more complicated variants of the âslow changeâ setting, such as when each armâs expected reward follows a random walk.
Swap regret. Let us consider a strong benchmark that depends not only on the costs but on the algorithm itself. Informally, what if we consider the sequence of actions chosen by the algorithm, and swap each occurrence of each action $a$ with $\pi(a)$ , according to some fixed swapping policy $\pi:[K]\mapsto[K]$ . The algorithm competes with the best swapping policy. More formally, we define swap regret as
$$
\displaystyle R_{\mathtt{swap}}(T)=\mathtt{cost}(\mathtt{ALG})-\min_{\text{swapping policies $\pi\in\mathcal{F}$}}\quad\sum_{t\in[T]}c_{t}(\pi(a_{t})), \tag{92}
$$
where $\mathcal{F}$ is the class of all swapping policies. The standard definition of regret corresponds to a version of (92), where $\mathcal{F}$ is the set of all âconstantâ swapping functions (i.e., those that map all arms to the same one).
The best known regret bound for swap regret is $\tilde{O}(K\sqrt{T})$ (Stoltz, 2005). Swapping regret has been introduced (Blum and Mansour, 2007), who also provided an explicit transformation that takes an algorithm with a âstandardâ regret bound, and transforms it into an algorithm with a bound on swap regret. Plugging in $\mathtt{Exp3}$ algorithm, this approach results in $\tilde{O}(K\sqrt{KT})$ regret rate. For the full-feedback version, the same approach achieves $\tilde{O}(\sqrt{KT})$ regret rate, with a matching lower bound. All algorithmic results are for an oblivious adversary; the lower bound is for adaptive adversary.
Earlier literature in theoretical economics, starting from (Hart and Mas-Colell, 2000), designed algorithms for a weaker notion called internal regret (Foster and Vohra, 1997, 1998, 1999; Cesa-Bianchi and Lugosi, 2003). The latter is defined as a version of (92) where $\mathcal{F}$ consists of swapping policies that change only one arm. The main motivation was its connection to equilibria in repeated games, more on this in Section 53. Note that the swap regret is at most $K$ times internal regret.
Counterfactual regret. The notion of âbest-observed armâ is not entirely satisfying for adaptive adversaries, as discussed in Section 25. Instead, one can consider a counterfactual notion of regret, which asks what would have happened if the algorithm actually played this arm in every round. The benchmark is the best fixed arm, but in this counterfactual sense. Sublinear regret is impossible against unrestricted adversaries. However, one can obtain non-trivial results against memory-restricted adversaries: ones that can use only $m$ most recent rounds. In particular, one can obtain $\tilde{O}(mK^{1/3}T^{2/3})$ counterfactual regret for all $m<T^{2/3}$ , without knowing $m$ . This can be achieved using a simple âbatchingâ trick: use some bandit algorithm $\mathtt{ALG}$ so that one round in the execution of $\mathtt{ALG}$ corresponds to a batch of $\tau$ consecutive rounds in the original problems. This result is due to Dekel et al. (2012); a similar regret bound for the full-feedback case has appeared in an earlier paper (Merhav et al., 2002).
Regret relative to the best algorithm. Given a (small) family $\mathcal{F}$ of algorithms, can one design a âmeta-algorithmâ which, on each problem instance, does almost as well as the best algorithm in $\mathcal{F}$ ? This is an extremely difficult benchmark, even if each algorithm in $\mathcal{F}$ has a very small set $S$ of possible internal states. Even with $|S|†3$ (and only $3$ algorithms and $3$ actions), no âmeta-algorithmâ can achieve expected regret better than $O(T\log^{-3/2}T)$ relative to the best algorithm in $\mathcal{F}$ (henceforth, $\mathcal{F}$ -regret). Surprisingly, there is an intricate algorithm which obtains a similar upper bound on $\mathcal{F}$ -regret, $O(\sqrt{K|S|}· T·\log^{-\Omega(1)}T)$ . Both results are from Feige et al. (2017).
Agarwal et al. (2017c) bypass these limitations and design a âmeta-algorithmâ with much more favorable bounds on $\mathcal{F}$ -regret. This comes at a cost of substantial assumptions on the algorithmsâ structure and a rather unwieldy fine-print in the regret bounds. Nevertheless, their regret bounds have been productively applied, e.g., in Krishnamurthy et al. (2020).
36 Exercises and hints
**Exercise 6.1 (lower bound)**
*Consider adversarial bandits with experts advice. Prove the lower bound in (87) for any given $(K,N,T)$ . More precisely: construct a randomized problem instance for which any algorithm satisfies (87). Hint: Split the time interval $1..T$ into $M=\tfrac{\ln N}{\ln K}$ non-overlapping sub-intervals of duration $T/M$ . For each sub-interval, construct the randomized problem instance from Chapter 2 (independently across the sub-intervals). Each expert recommends the same arm within any given sub-interval; the set of experts includes all experts of this form.*
**Exercise 6.2 (fixed discretization)**
*Let us extend the fixed discretization approach from Chapter 4 to adversarial bandits. Consider adversarial bandits with the set of arms $\mathcal{A}=[0,1]$ . Fix $\epsilon>0$ and let $S_{\epsilon}$ be the $\epsilon$ -uniform mesh over $\mathcal{A}$ , i.e., the set of all points in $[0,1]$ that are integer multiples of $\epsilon$ . For a subset $Sâ\mathcal{A}$ , the optimal total cost is $\mathtt{cost}^{*}(S):=\min_{aâ S}\mathtt{cost}(a)$ , and the discretization error is defined as $\mathtt{DE}(S_{\epsilon})=\left(\,\mathtt{cost}^{*}(S)-\mathtt{cost}^{*}(\mathcal{A})\,\right)/T$ . - Prove that $\mathtt{DE}(S_{\epsilon})†L\epsilon$ , assuming Lipschitz property:
$$
\displaystyle|c_{t}(a)-c_{t}(a^{\prime})|\leq L\cdot|a-a^{\prime}|\quad\text{for all arms $a,a^{\prime}\in\mathcal{A}$ and all rounds $t$}. \tag{93}
$$
- Consider a version of dynamic pricing (see Section 24.4), where the values $v_{1}\,,\ ...\ ,v_{T}$ are chosen by a deterministic, oblivious adversary. For compatibility, state the problem in terms of costs rather than rewards: in each round $t$ , the cost is $-p_{t}$ if there is a sale, $0$ otherwise. Prove that $\mathtt{DE}(S_{\epsilon})â€\epsilon$ .
Note: It is a special case of adversarial bandits with some extra structure which allows us to bound discretization error without assuming Lipschitzness.
- Assume that $\mathtt{DE}(S_{\epsilon})â€\epsilon$ for all $\epsilon>0$ . Obtain an algorithm with regret $\operatornamewithlimits{\mathbb{E}}[R(T)]†O(T^{2/3}\log T)$ .
Hint: Use algorithm $\mathtt{Exp3}$ with arms $Sâ\mathcal{A}$ , for a well-chosen subset $S$ .*
**Exercise 6.3 (slowly changing costs)**
*Consider a randomized oblivious adversary such that the expected cost of each arm changes by at most $\epsilon$ from one round to another, for some fixed and known $\epsilon>0$ . Use algorithm $\mathtt{Exp4}$ to obtain dynamic regret
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}[R^{*}(T)]\leq O(T)\cdot(\epsilon\cdot K\log K)^{1/3}. \tag{94}
$$ Hint: Recall the application of $\mathtt{Exp4}$ to $n$ -shifting regret, denote it $\mathtt{Exp4}(n)$ . Let $\mathtt{OPT}_{n}=\min\mathtt{cost}(\pi)$ , where the $\min$ is over all $n$ -shifting policies $\pi$ , be the benchmark in $n$ -shifting regret. Analyze the âdiscretization errorâ: the difference between $\mathtt{OPT}_{n}$ and $\mathtt{OPT}^{*}=\sum_{t=1}^{T}\min_{a}c_{t}(a)$ , the benchmark in dynamic regret. Namely: prove that $\mathtt{OPT}_{n}-\mathtt{OPT}^{*}†O(\epsilon T^{2}/n)$ . Derive an upper bound on dynamic regret that is in terms of $n$ . Optimize the choice of $n$ .*
Chapter 7 Linear Costs and Semi-Bandits
This chapter provides a joint introduction to several related lines of work: online routing, combinatorial (semi-)bandits, linear bandits, and online linear optimization. We study bandit problems with linear costs: actions are represented by vectors in $\mathbb{R}^{d}$ , and their costs are linear in this representation. This problem is challenging even under full feedback, let alone bandit feedback; we also consider an intermediate regime called semi-bandit feedback. We start with an important special case called online routing, and its generalization, combinatorial semi-bandits. We solve both using a version of the bandits-to- $\mathtt{Hedge}$ reduction from Chapters 6. However, this solution is slow. To remedy this, we focus on the full-feedback problem, a.k.a. online linear optimization. We present a fundamental algorithm for this problem, called Follow The Perturbed Leader, which plugs nicely into the bandits-to-experts reduction and makes it computationally efficient.
Prerequisites: Chapters 5 - 6.
We consider linear costs throughout this chapter. As in the last two chapters, there are $K$ actions and a fixed time horizon $T$ , and each action $aâ[K]$ yields cost $c_{t}(a)â„ 0$ at each round $tâ[T]$ . Actions are represented by low-dimensional real vectors; for simplicity, we assume that all actions lie within a unit hypercube: $aâ[0,1]^{d}$ . Action costs are linear in $a$ , namely: $c_{t}(a)=a· v_{t}$ for some weight vector $v_{t}â\mathbb{R}^{d}$ which is the same for all actions, but depends on the current time step.
Recap: bandits-to-experts reduction
We build on the bandits-to-experts reduction from Chapter 6. We will use it in a more abstract version, spelled out in Algorithm 1, with arbitrary âfake costsâ and an arbitrary full-feedback algorithm. We posit that experts correspond to arms, i.e., for each arm there is an expert that always recommends this arm.
Given: an algorithm $\mathtt{ALG}$ for online learning with experts, and parameter $\gammaâ(0,\tfrac{1}{2})$ .
Problem: adversarial bandits with $K$ arms and $T$ rounds; âexpertsâ correspond to arms.
In each round $tâ[T]$ :
1. call $\mathtt{ALG}$ , receive an expert $x_{t}$ chosen for this round,
where $x_{t}$ is an independent draw from some distribution $p_{t}$ over the experts.
2.
with probability $1-\gamma$ follow expert $x_{t}$ ;
else, chose arm via a version of ârandom explorationâ (TBD)
3.
observe cost $c_{t}$ for the chosen arm, and perhaps some extra feedback (TBD) 4.
define âfake costsâ $\widehat{c}_{t}(x)$ for each expert $x$ (TBD), and return them to $\mathtt{ALG}$ .
Algorithm 1 Reduction from bandit feedback to full feedback.
We assume that âfake costsâ are bounded from above and satisfy (88), and that $\mathtt{ALG}$ satisfies a regret bound against an adversary with bounded costs. For notation, an adversary is called $u$ -bounded if $c_{t}(·)†u$ . While some steps in the algorithm are unspecified, the analysis from Chapter 6 carries over word-by-word no matter how these missing steps are filled in, and implies the following theorem.
**Theorem 7.1**
*Consider Algorithm 1 with algorithm $\mathtt{ALG}$ that achieves regret bound $\operatornamewithlimits{\mathbb{E}}[R(T)]†f(T,K,u)$ against adaptive, $u$ -bounded adversary, for any given $u>0$ that is known to the algorithm. Consider adversarial bandits with a deterministic, oblivious adversary. Assume âfake costsâ satisfy
$$
\operatornamewithlimits{\mathbb{E}}\left[\,\widehat{c}_{t}(x)\mid p_{t}\,\right]=c_{t}(x)\text{ and }\widehat{c}_{t}(x)\leq u/\gamma\qquad\text{for all experts $x$ and all rounds $t$},
$$
where $u$ is some number that is known to the algorithm. Then Algorithm 1 achieves regret
| | $\displaystyle\operatornamewithlimits{\mathbb{E}}[R(T)]†f(T,K,u/\gamma)+\gamma T.$ | |
| --- | --- | --- |*
**Corollary 7.2**
*If $\mathtt{ALG}$ is $\mathtt{Hedge}$ in the theorem above, one can take $f(T,K,u)=O(u·\sqrt{T\ln{K}})$ by Theorem 5.16. Then, setting $\gamma=T^{-1/4}\;\sqrt{u·\log K}$ , Algorithm 1 achieves regret
$$
\operatornamewithlimits{\mathbb{E}}[R(T)]\leq O\left(\,T^{3/4}\;\sqrt{u\cdot\log K}\,\right).
$$*
We instantiate this algorithm, i.e., specify the missing pieces, to obtain a solution for some special cases of linear bandits that we define below.
37 Online routing problem
Let us consider an important special case of linear bandits called the online routing problem, a.k.a. online shortest paths. We are given a graph $G$ with $d$ edges, a source node $u$ , and a destination node $v$ . The graph can either be directed or undirected. We have costs on edges that we interpret as delays in routing, or lengths in a shortest-path problem. The cost of a path is the sum over all edges in this path. The costs can change over time. In each round, an algorithm chooses among âactionsâ that correspond to $u$ - $v$ paths in the graph. Informally, the algorithmâs goal in each round is to find the âbest routeâ from $u$ to $v$ : an $u$ - $v$ path with minimal cost (i.e., minimal travel time). More formally, the problem is as follows:
Problem protocol: Online routing problem
Given: graph $G$ , source node $u$ , destination node $v$ .
For each round $tâ[T]$ :
1. Adversary chooses costs $c_{t}(e)â[0,1]$ for all edges $e$ .
1. Algorithm chooses $u$ - $v$ -path $a_{t}â\mathtt{Edges}(G)$ .
1. Algorithm incurs cost $c_{t}(a_{t})=\sum_{eâ a_{t}}a_{e}· c_{t}(e)$ and receives feedback.
To cast this problem as a special case of âlinear banditsâ, note that each path can be specified by a subset of edges, which in turn can be specified by a $d$ -dimensional binary vector $aâ\{0,1\}^{d}$ . Here edges of the graph are numbered from $1$ to $d$ , and for each edge $e$ the corresponding entry $a_{e}$ equals 1 if and only if this edge is included in the path. Let $v_{t}=(c_{t}(e):\text{edges $eâ G$})$ be the vector of edge costs at round $t$ . Then the cost of a path can be represented as a linear product $c_{t}(a)=a· v_{t}=\sum_{eâ[d]}a_{e}\;c_{t}(e)$ .
There are three versions of the problem, depending on which feedback is received:
- Bandit feedback: only $c_{t}(a_{t})$ is observed;
- Semi-bandit feedback: costs $c_{t}(e)$ for all edges $eâ a_{t}$ are observed;
- Full feedback: costs $c_{t}(e)$ for all edges $e$ are observed.
Semi-bandit feedback is an intermediate âfeedback regimeâ which we will focus on.
Full feedback. The full-feedback version can be solved with $\mathtt{Hedge}$ algorithm. Applying Theorem 5.16 with a trivial upper bound $c_{t}(·)†d$ on action costs, and the trivial upper bound $K†2^{d}$ on the number of paths, we obtain regret $\operatornamewithlimits{\mathbb{E}}[R(T)]†O(d\sqrt{dT})$ .
**Corollary 7.3**
*Consider online routing with full feedback. Algorithm $\mathtt{Hedge}$ with with parameter $\epsilon=1/\sqrt{dT}$ achieves regret $\operatornamewithlimits{\mathbb{E}}[R(T)]†O(d\sqrt{dT})$ .*
This regret bound is optimal up $O(\sqrt{d})$ factor (Koolen et al., 2010). (The root- $T$ dependence on $T$ is optimal, as per Chapter 2.) An important drawback of using $\mathtt{Hedge}$ for this problem is the running time, which is exponential in $d$ . We return to this issue in Section 39.
Semi-bandit feedback. We use the bandit-to-experts reduction (Algorithm 1) with $\mathtt{Hedge}$ algorithm, as a concrete and simple application of this machinery to linear bandits. We assume that the costs are selected by a deterministic oblivious adversary, and we do not worry about the running time.
As a preliminary attempt, we can use $\mathtt{Exp3}$ algorithm for this problem. However, expected regret would be proportional to square root of the number of actions, which in this case may be exponential in $d$ .
Instead, we seek a regret bound of the form:
| | $\displaystyle\operatornamewithlimits{\mathbb{E}}[R(T)]â€\operatornamewithlimits{poly}(d)· T^{\beta},\quad\text{where $\beta<1$}.$ | |
| --- | --- | --- |
To this end, we use Algorithm 1 with $\mathtt{Hedge}$ . The âextra informationâ in the reduction is the semi-bandit feedback. Recall that we also need to specify the ârandom explorationâ and the âfake costsâ.
For the ârandom exploration stepâ, instead of selecting an action uniformly at random (as we did in $\mathtt{Exp4}$ ), we select an edge $e$ uniformly at random, and pick the corresponding path $a^{(e)}$ as the chosen action. We assume that each edge $e$ belongs to some $u$ - $v$ path $a^{(e)}$ ; this is without loss of generality, because otherwise we can just remove this edge from the graph.
We define fake costs for each edge $e$ separately; the fake cost of a path is simply the sum of fake costs over its edges. Let $\Lambda_{t,e}$ be the event that in round $t$ , the algorithm chooses ârandom explorationâ, and in random exploration, it chooses edge $e$ . Note that $\Pr[\Lambda_{t,e}]=\gamma/d$ . The fake cost on edge $e$ is
$$
\displaystyle\widehat{c}_{t}(e)=\begin{cases}\frac{c_{t}(e)}{\gamma/d}&\text{if event $\Lambda_{t,e}$ happens}\\
0&\text{otherwise}\end{cases} \tag{95}
$$
This completes the specification of an algorithm for the online routing problem with semi-bandit feedback; we will refer to this algorithm as $\mathtt{SemiBanditHedge}$ .
As in the previous lecture, we prove that fake costs provide unbiased estimates for true costs:
| | $\displaystyle\operatornamewithlimits{\mathbb{E}}[\widehat{c}_{t}(e)\mid p_{t}]=c_{t}(e)\quad\text{for each round $t$ and each edge $e$}.$ | |
| --- | --- | --- |
Since the fake cost for each edge is at most $d/\gamma$ , it follows that $c_{t}(a)†d^{2}/\gamma$ for each action $a$ . Thus, we can immediately use Corollary 7.2 with $u=d^{2}$ . For the number of actions, let us use an upper bound $K†2^{d}$ . Then $u\log K†d^{3}$ , and so:
**Theorem 7.4**
*Consider the online routing problem with semi-bandit feedback. Assume deterministic oblivious adversary. Algorithm $\mathtt{SemiBanditHedge}$ achieved regret $\operatornamewithlimits{\mathbb{E}}[R(T)]†O(d^{3/2}\;T^{3/4})$ .*
**Remark 7.5**
*Fake cost $\widehat{c}_{t}(e)$ is determined by the corresponding true cost $c_{t}(e)$ and event $\Lambda_{t,e}$ which does not depend on algorithmâs actions. Therefore, fake costs are chosen by a (randomized) oblivious adversary. In particular, in order to apply Theorem 7.1 with a different algorithm $\mathtt{ALG}$ for online learning with experts, it suffices to have an upper bound on regret against an oblivious adversary.*
38 Combinatorial semi-bandits
The online routing problem with semi-bandit feedback is a special case of combinatorial semi-bandits, where edges are replaced with $d$ âatomsâ, and $u$ - $v$ paths are replaced with feasible subsets of atoms. The family of feasible subsets can be arbitrary (but it is known to the algorithm).
Problem protocol: Combinatorial semi-bandits
Given: set $S$ of atoms, and a family $\mathcal{F}$ of feasible actions (subsets of $S$ ).
For each round $tâ[T]$ :
1. Adversary chooses costs $c_{t}(e)â[0,1]$ for all atoms $e$ ,
1. Algorithm chooses a feasible action $a_{t}â\mathcal{F}$ ,
1. Algorithm incurs cost $c_{t}(a_{t})=\sum_{eâ a_{t}}a_{e}· c_{t}(e)$ and observes costs $c_{t}(e)$ for all atoms $eâ a_{t}$ .
The algorithm and analysis from the previous section does not rely on any special properties of $u$ - $v$ paths. Thus, they carry over word-by-word to combinatorial semi-bandits, replacing edges with atoms, and $u$ - $v$ paths with feasible subsets. We obtain the following theorem:
**Theorem 7.6**
*Consider combinatorial semi-bandits with deterministic oblivious adversary. Algorithm $\mathtt{SemiBanditHedge}$ achieved regret $\operatornamewithlimits{\mathbb{E}}[R(T)]†O(d^{3/2}\;T^{3/4})$ .*
Let us list a few other notable special cases of combinatorial semi-bandits:
- News Articles: a news site needs to select a subset of articles to display to each user. The user can either click on an article or ignore it. Here, rounds correspond to users, atoms are the news articles, the reward is 1 if it is clicked and $0$ otherwise, and feasible subsets can encode various constraints on selecting the articles.
- Ads: a website needs select a subset of ads to display to each user. For each displayed ad, we observe whether the user clicked on it, in which case the website receives some payment. The payment may depend on both the ad and on the user. Mathematically, the problem is very similar to the news articles: rounds correspond to users, atoms are the ads, and feasible subsets can encode constraints on which ads can or cannot be shown together. The difference is that the payments are no longer 0-1.
- A slate of news articles: Similar to the news articles problem, but the ordering of the articles on the webpage matters. This the news site needs to select a slate (an ordered list) of articles. To represent this problem as an instance of combinatorial semi-bandits, define each âatomâ to mean âthis news article is chosen for that slotâ. A subset of atoms is feasible if it defines a valid slate: i.e., there is exactly one news article assigned to each slot.
Thus, combinatorial semi-bandits is a general setting which captures several motivating examples, and allows for a unified solution. Such results are valuable even if each of the motivating examples is only a very idealized version of reality, i.e., it captures some features of reality but ignores some others.
Low regret and running time. Recall that $\mathtt{SemiBanditHedge}$ is slow: its running time per round is exponential in $d$ , as it relies on $\mathtt{Hedge}$ with this many experts. We would like it to be polynomial in $d$ .
One should not hope to accomplish this in the full generality of combinatorial bandits. Indeed, even if the costs on all atoms were known, choosing the best feasible action (a feasible subset of minimal cost) is a well-known problem of combinatorial optimization, which is NP-hard. However, combinatorial optimization allows for polynomial-time solutions in many interesting special cases. For example, in the online routing problem discussed above the corresponding combinatorial optimization problem is a well-known shortest-path problem. Thus, a natural approach is to assume that we have access to an optimization oracle: an algorithm which finds the best feasible action given the costs on all atoms, and express the running time of our algorithm in terms of the number of oracle calls.
In Section 39, we use this oracle to construct a new algorithm for combinatorial bandits with full feedback, called Follow The Perturbed Leader ( $\mathtt{FTPL}$ ). In each round, this algorithm inputs only the costs on the atoms, and makes only one oracle call. We derive a regret bound
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}[R(T)]\leq O(u\sqrt{dT}) \tag{96}
$$
against an oblivious, $u$ -bounded adversary such that the atom costs are at most $\nicefrac{{u}}{{d}}$ . (Recall that a regret bound against an oblivious adversary suffices for our purposes, as per Remark 7.5.)
We use algorithm $\mathtt{SemiBanditHedge}$ as before, but replace $\mathtt{Hedge}$ with $\mathtt{FTPL}$ ; call the new algorithm $\mathtt{SemiBanditFTPL}$ . The analysis from Section 37 carries over to $\mathtt{SemiBanditFTPL}$ . We take $u=d^{2}/\gamma$ as a known upper bound on the fake costs of actions, and note that the fake costs of atoms are at most $\nicefrac{{u}}{{d}}$ . Thus, we can apply Theorem 7.1 for $\mathtt{FTPL}$ with fake costs, and obtain regret
| | $\displaystyle\operatornamewithlimits{\mathbb{E}}[R(T)]†O(u\sqrt{dT})+\gamma T.$ | |
| --- | --- | --- |
Optimizing the choice of parameter $\gamma$ , we immediately obtain the following theorem:
**Theorem 7.7**
*Consider combinatorial semi-bandits with deterministic oblivious adversary. Then algorithm $\mathtt{SemiBanditFTPL}$ with appropriately chosen parameter $\gamma$ achieved regret
$$
\operatornamewithlimits{\mathbb{E}}[R(T)]\leq O\left(d^{5/4}\;T^{3/4}\right).
$$*
**Remark 7.8**
*In terms of the running time, it is essential that the fake costs on atoms can be computed fast: this is because the normalizing probability in (95) is known in advance. Alternatively, we could have defined fake costs on atoms $e$ as
| | $\displaystyle\widehat{c}_{t}(e)=\begin{cases}c_{t}(e)/\Pr[eâ a_{t}\mid p_{t}]&\text{if $eâ a_{t}$}\\
0&\text{otherwise}.\end{cases}$ | |
| --- | --- | --- |
This definition leads to essentially the same regret bound (and, in fact, is somewhat better in practice). However, computing the probability $\Pr[eâ a_{t}\mid p_{t}]$ in a brute-force way requires iterating over all actions, which leads to running times exponential in $d$ , similar to $\mathtt{Hedge}$ .*
**Remark 7.9**
*Solving a version with bandit feedback requires more work. The main challenge is to estimate fake costs for all atoms in the chosen action, whereas we only observe the total cost for the action. One solution is to construct a suitable basis: a subset of feasible actions, called base actions, such that each action can be represented as a linear combination thereof. Then a version of Algorithm 1, where in the ârandom explorationâ step is uniform among the base actions, gives us fake costs for the base actions. The fake cost on each atom is the corresponding linear combination over the base actions. This approach works as long as the linear coefficients are small, and ensuring this property takes some work. This approach is worked out in Awerbuch and Kleinberg (2008), resulting in regret $\operatornamewithlimits{\mathbb{E}}[R(T)]â€\tilde{O}(d^{10/3}· T^{2/3})$ .*
39 Online Linear Optimization: Follow The Perturbed Leader
Let us turn our attention to online linear optimization, i.e., bandits with full-feedback and linear costs. We do not restrict ourselves to combinatorial actions, and instead allow an arbitrary subset $\mathcal{A}â[0,1]^{d}$ of feasible actions. This subset is fixed over time and known to the algorithm. Recall that in each round $t$ , the adversary chooses a âhidden vectorâ $v_{t}â\mathbb{R}^{d}$ , so that the cost for each action $aâ\mathcal{A}$ is $c_{t}(a)=a· v_{t}$ . We posit an upper bound on the costs: we assume that $v_{t}$ satisfies $v_{t}â[0,U/d]^{d}$ , for some known parameter $U$ , so that $c_{t}(a)†U$ for each action $a$ .
Problem protocol: Online linear optimization
For each round $tâ[T]$ :
1. Adversary chooses hidden vector $v_{t}â\mathbb{R}^{d}$ .
1. Algorithm chooses action $a=a_{t}â\mathcal{A}â[0,1]^{d}$ ,
1. Algorithm incurs cost $c_{t}(a)=v_{t}· a$ and observes $v_{t}$ .
We design an algorithm, called Follow The Perturbed Leader ( $\mathtt{FTPL}$ ), that is computationally efficient and satisfies regret bound (96). In particular, this suffices to complete the proof of Theorem 7.7.
We assume than the algorithm has access to an optimization oracle: a subroutine which computes the best action for a given cost vector. Formally, we represent this oracle as a function $M$ from cost vectors to feasible actions such that $M(v)â\operatornamewithlimits{argmin}_{aâ\mathcal{A}}a· v$ (ties can be broken arbitrarily). As explained earlier, while in general the oracle is solving an NP-hard problem, polynomial-time algorithms exist for important special cases such as shortest paths. The implementation of the oracle is domain-specific, and is irrelevant to our analysis. We prove the following theorem:
**Theorem 7.10**
*Assume that $v_{t}â[0,U/d]^{d}$ for some known parameter $U$ . Algorithm $\mathtt{FTPL}$ achieves regret $\operatornamewithlimits{\mathbb{E}}[R(T)]†2U·\sqrt{dT}$ . The running time in each round is polynomial in $d$ plus one call to the oracle.*
**Remark 7.11**
*The set of feasible actions $\mathcal{A}$ can be infinite, as long as a suitable oracle is provided. For example, if $\mathcal{A}$ is defined by a finite number of linear constraints, the oracle can be implemented via linear programming. Whereas $\mathtt{Hedge}$ is not even well-defined for infinitely many actions.*
We use shorthand $v_{i:j}=\sum_{t=i}^{j}v_{t}â\mathbb{R}^{d}$ to denote the total cost vector between rounds $i$ and $j$ .
Follow The Leader. Consider a simple, exploitation-only algorithm called Follow The Leader:
$$
a_{t+1}=M(v_{1:t}).
$$
Equivalently, we play an arm with the lowest average cost, based on the observations so far.
While this approach works fine for IID costs, it breaks for adversarial costs. The problem is synchronization: an oblivious adversary can force the algorithm to behave in a particular way, and synchronize its costs with algorithmâs actions in a way that harms the algorithm. In fact, this can be done to any deterministic online learning algorithm, as per Theorem 5.11. For concreteness, consider the following example:
$$
\begin{split}\mathcal{A}&=\{(1,0),\;(0,1)\}\\
v_{1}&=(\tfrac{1}{3},\tfrac{2}{3})\\
v_{t}&=\begin{cases}(1,0)&\text{if $t$ is even,}\\
(0,1)&\text{if $t$ is odd.}\end{cases}\\
\end{split}
$$
Then the total cost vector is
$$
v_{1:t}=\begin{cases}(i+\frac{1}{3},i-\frac{1}{3})&\text{if $t=2i$,}\\
(i+\frac{1}{3},i+\frac{2}{3})&\text{if $t=2i+1$.}\end{cases}
$$
Therefore, Follow The Leader picks action $a_{t+1}=(0,1)$ if $t$ is even, and $a_{t+1}=(1,0)$ if $t$ is odd. In both cases, we see that $c_{t+1}(a_{t+1})=1$ . So the total cost for the algorithm is $T$ , whereas any fixed action achieves total cost at most $1+T/2$ , so regret is, essentially, $T/2$ .
Fix: perturb the history! Let us use randomization to side-step the synchronization issue discussed above. We perturb the history before handing it to the oracle. Namely, we pretend there was a $0$ -th round, with cost vector $v_{0}â\mathbb{R}^{d}$ sampled from some distribution $\mathcal{D}$ . We then give the oracle the âperturbed historyâ, as expressed by the total cost vector $v_{0:t-1}$ , namely $a_{t}=M(v_{0:t-1})$ . This modified algorithm is known as Follow The Perturbed Leader ( $\mathtt{FTPL}$ ).
Sample $v_{0}â\mathbb{R}^{d}$ from distribution $\mathcal{D}$ ;
for each round $t=1,2,...$ do
Choose arm $a_{t}=M(v_{0:t-1})$ , where $v_{i:j}=\sum_{t=i}^{j}v_{t}â\mathbb{R}^{d}$ .
end for
Algorithm 2 Follow The Perturbed Leader ( $\mathtt{FTPL}$ ).
Several choices for distribution $\mathcal{D}$ lead to meaningful analyses. For ease of exposition, we posit that each each coordinate of $v_{0}$ is sampled independently and uniformly from the interval $[-\frac{1}{\epsilon},\frac{1}{\epsilon}]$ . The parameter $\epsilon$ can be tuned according to $T$ , $U$ , and $d$ ; in the end, we use $\epsilon=\frac{\sqrt{d}}{U\sqrt{T}}$ .
Analysis of the algorithm
As a tool to analyze $\mathtt{FTPL}$ , we consider a closely related algorithm called Be The Perturbed Leader ( $\mathtt{BTPL}$ ). Imagine that when we need to choose an action at time $t$ , we already know the cost vector $v_{t}$ , and in each round $t$ we choose $a_{t}=M(v_{0:t})$ . Note that $\mathtt{BTPL}$ is not an algorithm for online learning with experts; this is because it uses $v_{t}$ to choose $a_{t}$ .
The analysis proceeds in two steps. We first show that $\mathtt{BTPL}$ comes âcloseâ to the optimal cost
$$
\mathtt{OPT}=\min_{a\in\mathcal{A}}\mathtt{cost}(a)=v_{1:t}\cdot M(v_{1:t}),
$$
and then we show that $\mathtt{FTPL}$ comes âcloseâ to $\mathtt{BTPL}$ . Specifically, we will prove:
**Lemma 7.12**
*For each value of parameter $\epsilon>0$ ,
- $\mathtt{cost}(\mathtt{BTPL})â€\mathtt{OPT}+\frac{d}{\epsilon}$
- $\operatornamewithlimits{\mathbb{E}}[\mathtt{cost}(\mathtt{FTPL})]â€\operatornamewithlimits{\mathbb{E}}[\mathtt{cost}(\mathtt{BTPL})]+\epsilon· U^{2}· T$*
Then choosing $\epsilon=\frac{\sqrt{d}}{U\sqrt{T}}$ gives Theorem 7.10. Curiously, note that part (i) makes a statement about realized costs, rather than expected costs.
Step I: $\mathtt{BTPL}$ comes close to $\mathtt{OPT}$
By definition of the oracle $M$ , it holds that
$$
\displaystyle v\cdot M(v)\leq v\cdot a\quad\text{for any cost vector $v$ and feasible action $a$}. \tag{97}
$$
The main argument proceeds as follows:
$$
\displaystyle\mathtt{cost}(\mathtt{BTPL})+v_{0}\cdot M(v_{0}) \displaystyle=\sum_{t=0}^{T}v_{t}\cdot M(v_{0:T}) \displaystyle\leq v_{0:T}\cdot M(v_{0:T}) \displaystyle\leq v_{0:T}\cdot M(v_{1:T}) \displaystyle=v_{0}\cdot M(v_{1:T})+\underbrace{v_{1:T}\cdot M(v_{1:T})}_{\text{$\mathtt{OPT}$}}. \tag{98}
$$
Subtracting $v_{0}· M(v_{0})$ from both sides, we obtain Lemma 7.12 (i):
| | $\displaystyle\mathtt{cost}(\mathtt{BTPL})-\mathtt{OPT}â€\underbrace{v_{0}}_{â[-\frac{1}{\epsilon},-\frac{1}{\epsilon}]^{d}}·\underbrace{[M(v_{1:T})-M(v_{0})]}_{â[-1,1]^{d}}â€\frac{d}{\epsilon}.$ | |
| --- | --- | --- |
The missing step (98) follows from the following claim, with $i=0$ and $j=T$ .
**Claim 7.13**
*For all rounds $i<j$ , $\sum_{t=1}^{j}v_{t}· M(v_{i:t})†v_{i:j}· M(v_{i:j})$ .*
* Proof*
The proof is by induction on $j-i$ . The claim is trivially satisfied for the base case $i=j$ . For the inductive step:
$$
\displaystyle\sum_{t=i}^{j-1}v_{t}\cdot M(v_{i:t}) \displaystyle\leq v_{i:j-1}\cdot M(v_{i:j-1}) \displaystyle\leq v_{i:j-1}\cdot M(v_{i:j}) \displaystyle\text{\emph{(by (\ref{lin:eq:FPL-analysis-M}) with $a=M(v_{i:j})$)}}. \tag{97}
$$
Add $v_{j}· M(v_{i:j})$ to both sides to complete the proof. â
Step II: $\mathtt{FTPL}$ comes close to $\mathtt{BTPL}$
We compare the expected costs of $\mathtt{FTPL}$ and $\mathtt{BTPL}$ round per round. Specifically, we prove that
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}[\;\underbrace{v_{t}\cdot M(v_{0:t-1})}_{\text{$c_{t}(a_{t})$ for $\mathtt{FTPL}$}}\;]\leq\operatornamewithlimits{\mathbb{E}}[\;\underbrace{v_{t}\cdot M(v_{0:t})}_{\text{$c_{t}(a_{t})$ for $\mathtt{BTPL}$}}\;]+\epsilon U^{2}. \tag{99}
$$
Summing up over all $T$ rounds gives Lemma 7.12 (ii).
It turns out that for proving (99) much of the structure in our problem is irrelevant. Specifically, we can denote $f(u)=v_{t}· M(u)$ and $v=v_{1:t-1}$ , and, essentially, prove (99) for arbitrary $f()$ and $v$ .
**Claim 7.14**
*For any vectors $vâ\mathbb{R}^{d}$ and $v_{t}â[0,U/d]^{d}$ , and any function $f:\mathbb{R}^{d}â[0,R]$ ,
| | $\displaystyle\left|\operatornamewithlimits{\mathbb{E}}_{v_{0}\sim\mathcal{D}}\left[f(v_{0}+v)-f(v_{0}+v+v_{t})\right]\right|â€\epsilon UR.$ | |
| --- | --- | --- |*
In words: changing the input of function $f$ from $v_{0}+v$ to $v_{0}+v+v_{t}$ does not substantially change the output, in expectation over $v_{0}$ . What we actually prove is the following:
**Claim 7.15**
*Fix $v_{t}â[0,U/d]^{d}$ . There exists a random variable $v^{\prime}_{0}â\mathbb{R}^{d}$ such that (i) $v^{\prime}_{0}$ and $v_{0}+v_{t}$ have the same marginal distribution, and (ii) $\Pr[v^{\prime}_{0}â v_{0}]â€\epsilon U$ .*
It is easy to see that Claim 7.14 follows from Claim 7.15:
| | $\displaystyle\left|\;\operatornamewithlimits{\mathbb{E}}\left[f(v_{0}+v)-f(v_{0}+v+v_{t})\right]\;\right|$ | $\displaystyle=\left|\;\operatornamewithlimits{\mathbb{E}}\left[f(v_{0}+v)-f(v^{\prime}_{0}+v)\right]\;\right|$ | |
| --- | --- | --- | --- |
It remains to prove Claim 7.15. First, let us prove this claim in one dimension:
**Claim 7.16**
*let $X$ be a random variable uniformly distributed on the interval $[-\frac{1}{\epsilon},\frac{1}{\epsilon}]$ . We claim that for any $aâ[0,U/d]$ there exists a deterministic function $g(X,a)$ of $X$ and $a$ such that $g(X,a)$ and $X+a$ have the same marginal distribution, and $\Pr[g(X,a)â X]â€\epsilon U/d$ .*
* Proof*
Let us define
| | $\displaystyle g(X,a)=\begin{cases}X&\text{if $Xâ[v-\frac{1}{\epsilon},\frac{1}{\epsilon}]$},\\
a-X&\text{if $Xâ[-\frac{1}{\epsilon},v-\frac{1}{\epsilon})$}.\end{cases}$ | |
| --- | --- | --- |
It is easy to see that $g(X,a)$ is distributed uniformly on $[v-\frac{1}{\epsilon},v+\frac{1}{\epsilon}]$ . This is because $a-X$ is distributed uniformly on $[\frac{1}{\epsilon},v+\frac{1}{\epsilon}]$ conditional on $Xâ[-\frac{1}{\epsilon},v-\frac{1}{\epsilon})$ . Moreover,
$$
\Pr[g(X,a)\neq X]\leq\Pr[X\not\in[v-\tfrac{1}{\epsilon},\tfrac{1}{\epsilon}]]=\epsilon v/2\leq\tfrac{\epsilon U}{2d}.\qed
$$
To complete the proof of Claim 7.15, write $v_{t}=(v_{t,1},v_{t,2}\,,\ ...\ ,v_{t,d})$ , and define $v^{\prime}_{0}â\mathbb{R}^{d}$ by setting its $j$ -th coordinate to $Y(v_{0,j},v_{t,j})$ , for each coordinate $j$ . We are done!
40 Literature review and discussion
This chapter touches upon several related lines of work: online routing, combinatorial (semi-)bandits, linear bandits, and online linear optimization. We briefly survey them below, along with some extensions.
Online routing and combinatorial (semi-)bandits. The study of online routing, a.k.a. online shortest paths, was initiated in Awerbuch and Kleinberg (2008), focusing on bandit feedback and achieving regret $\operatornamewithlimits{poly}(d)· T^{2/3}$ . Online routing with semi-bandit feedback was introduced in György et al. (2007), and the general problem of combinatorial bandits was initiated in Cesa-Bianchi and Lugosi (2012). Both papers achieve regret $\operatornamewithlimits{poly}(d)·\sqrt{T}$ , which is the best possible. Combinatorial semi-bandits admit improved dependence on $d$ and other problem parameters, e.g., for IID rewards (e.g., Chen et al., 2013; Kveton et al., 2015c, 2014) and when actions are âslatesâ of search results (Kale et al., 2010).
Linear bandits. A more general problem of linear bandits allows an arbitrary action set $\mathcal{A}â[0,1]^{d}$ , as in Chapter 39. Introduced in Awerbuch and Kleinberg (2008) and McMahan and Blum (2004), this problem has been studied in a long line of work. In particular, one can achieve $\operatornamewithlimits{poly}(d)·\sqrt{T}$ regret (Dani et al., 2007), even with high probability against an adaptive adversary (Bartlett et al., 2008), and even via a computationally efficient algorithm if $\mathcal{A}$ is convex (Abernethy et al., 2008; Abernethy and Rakhlin, 2009). A detailed survey of this line of work can be found in Bubeck and Cesa-Bianchi (2012, Chapter 5).
In stochastic linear bandits, $\operatornamewithlimits{\mathbb{E}}\left[\,c_{t}(a)\,\right]=v· a$ for each action $aâ\mathcal{A}$ and some fixed, unknown vector $v$ . One way to realize the stochastic version as a special case of the adversarial version is to posit that in each round $t$ , the hidden vector $v_{t}$ is drawn independently from some fixed (but unknown) distribution. Alternatively, one could realize $c_{t}(a)$ as $v· a$ plus independent noise $\epsilon_{t}$ . This version can also be represented as a special case of adversarial linear bandits, but in a more complicated way. Essentially, one more dimension is added, such that in this dimension each arm has coefficient $1$ , and each hidden vector $v_{t}$ has coefficient $\epsilon_{t}$ . Stochastic linear bandits have bee introduced in Auer (2002) and subsequently studied in (Abe et al., 2003; Dani et al., 2008; Rusmevichientong and Tsitsiklis, 2010) using the paradigm of âoptimism under uncertaintyâ from Chapter 1. Generally, regret bounds admit better dependence on $d$ compared to the adversarial version.
Several notable extensions of stochastic linear bandits have been studied. In contextual linear bandits, the action set is provided exogenously before each round, see Sections 43 for technical details and Section 47 for a literature review. In generalized linear bandits (starting from Filippi et al., 2010; Li et al., 2017), $\operatornamewithlimits{\mathbb{E}}\left[\,c_{t}(a)\,\right]=f(v· a)$ for some known function $f$ , building on the generalized linear model from statistics. In sparse linear bandits (starting from Abbasi-Yadkori et al., 2012; Carpentier and Munos, 2012), the dimension $d$ is very large, and one takes advantage of the sparsity in the hidden vector $v$ .
Online linear optimization. Follow The Perturbed Leader ( $\mathtt{FTPL}$ ) has been proposed in Hannan (1957), in the context of repeated games (as in Chapter 9). The algorithm was rediscovered in the computer science literature by Kalai and Vempala (2005), with an improved analysis.
While $\mathtt{FTPL}$ allows an arbitrary action set $\mathcal{A}â[0,1]^{d}$ , a vast and beautiful theory is developed for a paradigmatic special case when $\mathcal{A}$ is convex. In particular, Follow The Regularized Leader ( $\mathtt{FTRL}$ ) is another generalization of Follow The Leader which chooses a strongly convex regularization function $\mathcal{R}_{t}:\mathcal{A}â\mathbb{R}$ at each round $t$ , and minimizes the sum: $a_{t}=\operatornamewithlimits{argmin}_{aâ\mathcal{A}}\mathcal{R}_{t}(a)+\sum_{s=1}^{t}c_{s}(a)$ . The $\mathtt{FTRL}$ framework allows for a unified analysis and, depending on the choice of $\mathcal{R}_{t}$ , instantiates to many specific algorithms and their respective guarantees, see the survey (McMahan, 2017). In fact, this machinery extends to convex cost functions, a subject called online convex optimization. More background on this subject can be found in books (Shalev-Shwartz, 2012) and (Hazan, 2015). A version of $\mathtt{FTRL}$ achieves $\operatornamewithlimits{poly}(d)·\sqrt{T}$ regret for any convex $\mathcal{A}$ in a computationally efficient manner (Abernethy et al., 2008); in fact, it is a key ingredient in the $\operatornamewithlimits{poly}(d)·\sqrt{T}$ regret algorithm for linear bandits.
Lower bounds and optimality. In linear bandits, $\operatornamewithlimits{poly}(d)·\sqrt{T}$ regret rates are inevitable in the worst case. This holds even under full feedback (Dani et al., 2007), even for stochastic linear bandits with âcontinuousâ action sets (Dani et al., 2008), and even for stochastic combinatorial semi-bandits (e.g., Audibert et al., 2014; Kveton et al., 2015c). In particular, the âprice of bandit informationâ, i.e., the penalty in optimal regret bounds compared to the full-feedback version, is quite mild: the dependence on $d$ increases from one polynomial to another. This is in stark contrast with $K$ -armed bandits, where the dependence on $K$ increases from logarithmic to polynomial.
A considerable literature strives to improve dependence on $d$ and/or other structural parameters. This literature is concerned with both upper and lower bounds on regret, across the vast problem space of linear bandits. Some of the key distinctions in this problem space are as follows: feedback model (full, semi-bandit, or bandit); âtypeâ of the adversary (stochastic, oblivious, or adaptive); structure of the action space (e.g., arbitrary, convex, or combinatorial); One could also posit a more refined structure, e.g., assume a particular family of combinatorial subsets, such as $\{$ all subsets of a given size $\}$ , or $\{$ all paths in a graph $\}$ . Abernethy et al. (2008); Abernethy and Rakhlin (2009) express the ânicenessâ of a convex action set via the existence of an intricate object from convex optimization called âself-concordant barrier functionâ. structure of the hidden vector (e.g., sparsity). A detailed discussion of the âlandscapeâ of optimal regret bounds is beyond our scope.
Combinatorial semi-bandits beyond additive costs. Several versions of combinatorial semi-bandits allow the atomsâ costs to depend on the other atoms chosen in the same round. In much of this work, when a subset $S$ of atoms is chosen by the algorithm, at most one atom $aâ S$ is then selected by ânatureâ, and all other atoms receive reward/cost $0$ . In multinomial-logit (MNL) bandits, atoms are chosen probabilistically according to the MNL model, a popular choice model from statistics. Essentially, each atom $a$ is associated with a fixed (but unknown) number $v_{a}$ , and is chosen with probability ${\bf 1}_{\left\{\,aâ S\,\right\}}· v_{a}/(1+\sum_{a^{\prime}â S}v_{a^{\prime}})$ . MNL bandits are typically studied as a model for dynamic assortment, where $S$ is the assortment of products offered for sale, e.g., in (Caro and Gallien, 2007; SaurĂ© and Zeevi, 2013; Rusmevichientong et al., 2010; Agrawal et al., 2019). Simchowitz et al. (2016) consider a more general choice model from theoretical economics, called random utility model. Here each atom $aâ S$ is assigned âutilityâ equal to $v_{a}$ plus independent noise, and the atom with a largest utility is chosen.
A cascade feedback model posits that actions correspond to rankings of items such as search results, a user scrolls down to the first ârelevantâ item, clicks on it, and leaves. The reward is 1 if and only if some item is relevant (and therefore the user is satisfied). The study of bandits in this model has been initiated in (Radlinski et al., 2008). They allow relevance to be arbitrarily correlated across items, depending on the userâs interests. In particular, the marginal importance of a given item may depend on other items in the ranking, and it may be advantageous to make the list more diverse. Streeter and Golovin (2008); Golovin et al. (2009) study a more general version with submodular rewards, and Slivkins et al. (2013) consider an extension to Lipschitz bandits. In all this work, one only achieves additive regret relative to the $(1-1/e)$ -th fraction of the optimal reward. Kveton et al. (2015a, b); Zong et al. (2016) achieve much stronger guarantees, without the multiplicative approximation, assuming that relevance is independent across the items. Kveton et al. (2015b) study a version of cascade feedback in which the aggregate reward for a ranked list of items is 1 if all items are âgoodâ and 0 otherwise, and the feedback returns the first item that is âbadâ. The main motivation is network routing: an action corresponds to a path in the network, and it may be the case that only the first faulty edge is revealed to the algorithm.
In some versions of combinatorial semi-bandits, atoms are assigned rewards in each round independently of the algorithmâs choices, but the âaggregate outcomeâ associated with a particular subset $S$ of atoms chosen by the algorithm can be more general compared to the standard version. For example, Chen et al. (2016) allows the aggregate reward of $S$ to be a function of the per-atom rewards in $S$ , under some mild assumptions. Chen et al. (2013) allows other atoms to be âtriggeredâ, i.e., included into $S$ , according to some distribution determined by $S$ .
Chapter 8 Contextual Bandits
In contextual bandits, rewards in each round depend on a context, which is observed by the algorithm prior to making a decision. We cover the basics of three prominent versions of contextual bandits: with a Lipschitz assumption, with a linearity assumption, and with a fixed policy class. We also touch upon offline learning from contextual bandit data. Finally, we discuss challenges that arise in large-scale applications, and a system design that address these challenges in practice.
Prerequisites: Chapters 1, 2, 6 (for background/perspective only), Chapter 4 (for Section 42).
We consider a generalization called contextual bandits, defined as follows:
Problem protocol: Contextual bandits
For each round $tâ[T]$ :
- algorithm observes a âcontextâ $x_{t}$ ,
- algorithm picks an arm $a_{t}$ ,
- reward $r_{t}â[0,1]$ is realized.
The reward $r_{t}$ in each round $t$ depends both on the context $x_{t}$ and the chosen action $a_{t}$ . We make the IID assumption: reward $r_{t}$ is drawn independently from some distribution parameterized by the $(x_{t},a_{t})$ pair, but same for all rounds $t$ . The expected reward of action $a$ given context $x$ is denoted $\mu(a|x)$ . This setting allows a limited amount of âchange over timeâ, but this change is completely âexplainedâ by the observable contexts. We assume contexts $x_{1},x_{2},\;...$ are chosen by an oblivious adversary.
Several variants of this setting have been studied in the literature. We discuss three prominent variants in this chapter: with a Lipschitz assumption, with a linearity assumption, and with a fixed policy class.
Motivation. The main motivation is that a user with a known âuser profileâ arrives in each round, and the context is the user profile. The algorithm can personalize the userâs experience. Natural application scenarios include choosing which news articles to showcase, which ads to display, which products to recommend, or which webpage layouts to use. Rewards in these applications are often determined by user clicks, possibly in conjunction with other observable signals that correlate with revenue and/or user satisfaction. Naturally, rewards for the same action may be different for different users.
Contexts can include other things apart from (and instead of) user profiles. First, contexts can include known features of the environment, such as day of the week, time of the day, season (e.g., Summer, pre-Christmas shopping season), or proximity to a major event (e.g., Olympics, elections). Second, some actions may be unavailable in a given round and/or for a given user, and a context can include the set of feasible actions. Third, actions can come with features of their own, and it may be convenient to include this information into the context, esp. if these features can change over time.
Regret relative to best response. For ease of exposition, we assume a fixed and known time horizon $T$ . The set of actions and the set of all contexts are $\mathcal{A}$ and $\mathcal{X}$ , resp.; $K=|\mathcal{A}|$ is the number of actions.
The (total) reward of an algorithm $\mathtt{ALG}$ is $\mathtt{REW}(\mathtt{ALG})=\sum_{t=1}^{T}r_{t}$ , so that the expected reward is
$$
\operatornamewithlimits{\mathbb{E}}[\mathtt{REW}(\mathtt{ALG})]=\textstyle\sum_{t=1}^{T}\operatornamewithlimits{\mathbb{E}}\left[\,\mu(a_{t}|x_{t})\,\right].
$$
A natural benchmark is the best-response policy, $\pi^{*}(x)=\max_{aâ\mathcal{A}}\mu(a|x)$ . Then regret is defined as
$$
\displaystyle R(T)=\mathtt{REW}(\pi^{*})-\mathtt{REW}(\mathtt{ALG}). \tag{100}
$$
41 Warm-up: small number of contexts
One straightforward approach for contextual bandits is to apply a known bandit algorithm $\mathtt{ALG}$ such as $\mathtt{UCB1}$ : namely, run a separate copy of this algorithm for each context.
Initialization: For each context $x$ , create an instance $\mathtt{ALG}_{x}$ of algorithm $\mathtt{ALG}$
for each round $t$ do
invoke algorithm $\mathtt{ALG}_{x}$ with $x=x_{t}$
âplayâ action $a_{t}$ chosen by $\mathtt{ALG}_{x}$ , return reward $r_{t}$ to $\mathtt{ALG}_{x}$ .
end for
Algorithm 1 Contextual bandit algorithm for a small number of contexts
Let $n_{x}$ be the number of rounds in which context $x$ arrives. Regret accumulated in such rounds, denoted $R_{x}(T)$ , satisfies $\operatornamewithlimits{\mathbb{E}}[R_{x}(T)]=O(\sqrt{Kn_{x}\ln T})$ . The total regret (from all contexts) is
| | $\displaystyle\operatornamewithlimits{\mathbb{E}}[R(T)]=\textstyle\sum_{xâ\mathcal{X}}\operatornamewithlimits{\mathbb{E}}[R_{x}(T)]=\sum_{xâ\mathcal{X}}O(\sqrt{Kn_{x}\,\ln T})†O(\sqrt{KT\,|\mathcal{X}|\,\ln T}).$ | |
| --- | --- | --- |
**Theorem 8.1**
*Algorithm 1 has regret $\operatornamewithlimits{\mathbb{E}}[R(T)]=O(\sqrt{KT\,|\mathcal{X}|\,\ln T})$ , provided that the bandit algorithm $\mathtt{ALG}$ has regret $\operatornamewithlimits{\mathbb{E}}[R_{\mathtt{ALG}}(T)]=O(\sqrt{KT\log T})$ .*
**Remark 8.2**
*The square-root dependence on $|\mathcal{X}|$ is slightly non-trivial, because a completely naive solution would give linear dependence. However, this regret bound is still very high if $|\mathcal{X}|$ is large, e.g., if contexts are feature vectors with a large number of features. To handle contextual bandits with a large $|\mathcal{X}|$ , we either assume some structure (as in Sections 42 and 43, or change the objective (as in Section 44).*
42 Lipshitz contextual bandits
Let us consider contextual bandits with Lipschitz-continuity, as a simple end-to-end example of how structure allows to handle contextual bandits with a large number of contexts. We assume that contexts map into the $[0,1]$ interval (i.e., $\mathcal{X}â[0,1])$ so that the expected rewards are Lipschitz with respect to the contexts:
$$
\displaystyle|\mu(a|x)-\mu(a|x^{\prime})|\leq L\cdot|x-x^{\prime}|\quad\text{for any arm $a\in\mathcal{A}$ and any contexts $x,x^{\prime}\in\mathcal{X}$}, \tag{101}
$$
where $L$ is the Lipschitz constant which is known to the algorithm.
One simple solution for this problem is given by uniform discretization of the context space. The approach is very similar to what weâve seen for Lipschitz bandits and dynamic pricing; however, we need to be a little careful with some details: particularly, watch out for âdiscretized best responseâ. Let $S$ be the $\epsilon$ -uniform mesh on $[0,1]$ , i.e., the set of all points in $[0,1]$ that are integer multiples of $\epsilon$ . We take $\epsilon=1/(d-1)$ , where the integer $d$ is the number of points in $S$ , to be adjusted later in the analysis.
0 1 ⊠$\epsilon$
Figure 3: Discretization of the context space
We will use the contextual bandit algorithm from Section 41, applied to context space $S$ ; denote this algorithm as $\mathtt{ALG}_{S}$ . Let $f_{S}(x)$ be a mapping from context $x$ to the closest point in $S$ :
$$
f_{S}(x)=\min(\operatornamewithlimits{argmin}_{x^{\prime}\in S}|x-x^{\prime}|)
$$
(the $\min$ is added just to break ties). The overall algorithm proceeds as follows:
The regret bound will have two summands: regret bound for $\mathtt{ALG}_{S}$ and (a suitable notion of) discretization error. Formally, let us define the âdiscretized best responseâ $\pi^{*}_{S}:\mathcal{X}â\mathcal{A}$ :
$$
\pi^{*}_{S}(x)=\pi^{*}(f_{S}(x))\quad\text{for each context $x\in\mathcal{X}$}.
$$
Then regret of $\mathtt{ALG}_{S}$ and discretization error are defined as, resp.,
| | $\displaystyle R_{S}(T)$ | $\displaystyle=\mathtt{REW}(\pi^{*}_{S})-\mathtt{REW}(\mathtt{ALG}_{S})$ | |
| --- | --- | --- | --- |
It follows that the âoverallâ regret is the sum $R(T)=R_{S}(T)+\mathtt{DE}(S)$ , as claimed. We have $\operatornamewithlimits{\mathbb{E}}[R_{S}(T)]=O(\sqrt{KT|S|\ln T})$ from Lemma 8.1, so it remains to upper-bound the discretization error and adjust the discretization step $\epsilon$ .
**Claim 8.3**
*$\operatornamewithlimits{\mathbb{E}}[\mathtt{DE}(S)]â€\epsilon LT$ .*
* Proof*
For each round $t$ and the respective context $x=x_{t}$ ,
| | $\displaystyle\mu(\pi^{*}_{S}(x)\mid f_{S}(x))$ | $\displaystyleâ„\mu(\pi^{*}(x)\mid f_{S}(x))$ | (by optimality of $\pi^{*}_{S}$ ) | |
| --- | --- | --- | --- | --- |
Summing this up over all rounds $t$ , we obtain
$$
\operatornamewithlimits{\mathbb{E}}[\mathtt{REW}(\pi^{*}_{S})]\geq\mathtt{REW}[\pi^{*}]-\epsilon LT.\qed
$$
Thus, regret is
| | $\displaystyle\operatornamewithlimits{\mathbb{E}}[R(T)]â€\epsilon LT+O(\sqrt{\tfrac{1}{\epsilon}\,KT\ln T})=O(T^{2/3}(LK\ln T)^{1/3}).$ | |
| --- | --- | --- |
where for the last inequality we optimized the choice of $\epsilon$ .
**Theorem 8.4**
*Consider the Lipschitz contextual bandits problem with contexts in $[0,1]$ . The uniform discretization algorithm (102) yields regret $\operatornamewithlimits{\mathbb{E}}[R(T)]=O(T^{2/3}(LK\ln T)^{1/3})$ .*
An astute reader would notice a similarity with the uniform discretization result in Theorem 4.1. In fact, these two results admit a common generalization in which the Lipschitz condition applies to both contexts and arms, and arbitrary metrics are allowed. Specifically, the Lipschitz condition is now
$$
\displaystyle|\mu(a|x)-\mu(a^{\prime}|x^{\prime})|\leq D_{\mathcal{X}}(x,x^{\prime})+D_{\mathcal{A}}(a,a^{\prime})\quad\text{for any arms $a,a^{\prime}$ and contexts $x,x^{\prime}$}, \tag{103}
$$
where $D_{\mathcal{X}},D_{\mathcal{A}}$ are arbitrary metrics on contexts and arms, respectively, that are known to the algorithm. This generalization is fleshed out in Exercise 8.1.
43 Linear contextual bandits (no proofs)
We introduce the setting of linear contextual bandits, and define an algorithm for this setting called $\mathtt{LinUCB}$ .
Let us recap the setting of linear bandits from Chapter 7, specialized to stochastic bandits. One natural formulation is that each arm $a$ is characterized by a feature vector $x_{a}â[0,1]^{d}$ , and the expected reward is linear in this vector: $\mu(a)=x_{a}·\theta$ , for some fixed but unknown vector $\thetaâ[0,1]^{d}$ . The tuple
$$
\displaystyle x=\left(\,x_{a}\in\{0,1\}^{d}:a\in\mathcal{A}\,\right) \tag{104}
$$
can be interpreted as a static context, i.e., a context that does not change from one round to another.
In linear contextual bandits, contexts are of the form (104), and the expected rewards are linear:
$$
\displaystyle\mu(a|x)=x_{a}\cdot\theta_{a}\quad\text{for all arms $a$ and contexts $x$}, \tag{105}
$$
for some fixed but unknown vector $\theta=(\theta_{a}â\mathcal{R}^{d}:aâ\mathcal{A})$ . Note that we also generalize the unknown vector $\theta$ so that $\theta_{a}$ can depend on the arm $a$ . Let $\Theta$ be the set of all feasible $\theta$ vectors, known to the algorithm.
This problem can be solved by a version of the UCB technique. Instead of constructing confidence bounds on the mean rewards of each arm, we do that for the $\theta$ vector. Namely, in each round $t$ we construct a âconfidence regionâ $C_{t}â\Theta$ such that $\thetaâ C_{t}$ with high probability. Then we use $C_{t}$ to construct an UCB on the mean reward of each arm given context $x_{t}$ , and play an arm with the highest UCB. This algorithm, called $\mathtt{LinUCB}$ , is summarized in Algorithm 2.
for each round $t=1,2,...$ do
Form a confidence region $C_{t}â\Theta$ {i.e., $\thetaâ C_{t}$ with high probability}
Observe context $x=x_{t}$ of the form (104)
For each arm $a$ , compute $\mathtt{UCB}_{t}(a|x_{t})=\sup\limits_{\thetaâ C_{t}}x_{a}·\theta_{a}$
Pick an arm $a$ which maximizes $\mathtt{UCB}_{t}(a|x_{t})$ .
end for
Algorithm 2 $\mathtt{LinUCB}$ : UCB-based algorithm for linear contextual bandits
Suitably specified versions of $\mathtt{LinUCB}$ allow for rigorous regret bounds, and work well in experiments. The best known worst-case regret bound is $\operatornamewithlimits{\mathbb{E}}[R(T)]=\tilde{O}(d\sqrt{T})$ , and there is a close lower bound $\operatornamewithlimits{\mathbb{E}}[R(T)]â„\Omega(\sqrt{dT})$ . The gap-dependent regret bound from Chapter 1 carries over, too: $\mathtt{LinUCB}$ enjoys $(d^{2}/\Delta)·\operatornamewithlimits{polylog}(T)$ regret for problem instances with minimal gap at least $\Delta$ . Interestingly, the algorithm is known to work well in practice even for scenarios without linearity.
To completely specify the algorithm, one needs to specify what the confidence region is, and how to compute the UCBs; this is somewhat subtle, and there are multiple ways to do this. The technicalities of specification and analysis of LinUCB are beyond our scope.
44 Contextual bandits with a policy class
We now consider a more general contextual bandit problem where we do not make any assumptions on the mean rewards. Instead, we make the problem tractable by making restricting the benchmark in the definition of regret (i.e., the first term in Eq. (100)). Specifically, we define a policy as a mapping from contexts to actions, and posit a known class of policies $\Pi$ . Informally, algorithms only need to compete with the best policy in $\pi$ . A big benefit of this approach is that it allows to make a clear connection to the âtraditionalâ machine learning, and re-use some of its powerful tools.
We assume that contexts arrive as independent samples from some fixed distribution $\mathcal{D}$ over contexts. The expected reward of a given policy $\pi$ is then well-defined:
$$
\mu(\pi)=\operatornamewithlimits{\mathbb{E}}_{x\in\mathcal{D}}\left[\,\mu(\pi(x))\mid x\,\right]. \tag{106}
$$
This quantity, also known as policy value, gives a concrete way to compare policies to one another. The appropriate notion of regret, for an algorithm $\mathtt{ALG}$ , is relative to the best policy in a given policy class $\Pi$ :
$$
R_{\Pi}(T)=T\max_{\pi\in\Pi}\mu(\pi)-\mathtt{REW}(\mathtt{ALG}). \tag{107}
$$
Note that the definition (100) can be seen a special case when $\Pi$ is the class of all policies. For ease of presentation, we assume $K<â$ actions throughout; the set of actions is denoted $[K]$ .
**Remark 8.5 (Some examples)**
*A policy can be based on a score predictor: given a context $x$ , it assigns a numerical score $\nu(a|x)$ to each action $a$ . Such score can represent an estimated expected reward of this action, or some other quality measure. The policy simply picks an action with a highest predicted reward. For a concrete example, if contexts and actions are represented as known feature vectors in $\mathbb{R}^{d}$ , a linear score predictor is $\nu(a|x)=aMx$ , for some fixed $dĂ d$ weight matrix $M$ . A policy can also be based on a decision tree, a flowchart in which each internal node corresponds to a âtestâ on some attribute(s) of the context (e.g., is the user male of female), branches correspond to the possible outcomes of that test, and each terminal node is associated with a particular action. Execution starts from the âroot nodeâ of the flowchart and follows the branches until a terminal node is reached.*
Preliminary result. This problem can be solved with algorithm $\mathtt{Exp4}$ from Chapter 6, with policies $\piâ\Pi$ as âexpertsâ. Specializing Theorem 6.11 to the setting of contextual bandits, we obtain:
**Theorem 8.6**
*Consider contextual bandits with policy class $\Pi$ . Algorithm $\mathtt{Exp4}$ with expert set $\Pi$ yields regret $\operatornamewithlimits{\mathbb{E}}[R_{\Pi}(T)]=O(\sqrt{KT\log|\Pi|})$ . However, the running time per round is linear in $|\Pi|$ .*
This is a very powerful regret bound: it works for an arbitrary policy class $\Pi$ , and the logarithmic dependence on $|\Pi|$ makes it tractable even if the number of possible contexts is huge. Indeed, while there are $K^{|\mathcal{X}|}$ possible policies, for many important special cases $|\Pi|=K^{c}$ , where $c$ depends on the problem parameters but not on $|\mathcal{X}|$ . This regret bound is essentially the best possible. Specifically, there is a nearly matching lower bound (similar to (87)), which holds for any given triple of parameters $K,T,|\Pi|$ :
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}[R(T)]\geq\min\left(T,\;\Omega\left(\sqrt{KT\log(|\Pi|)/\log(K)}\right)\right). \tag{108}
$$
However, the running time of $\mathtt{Exp4}$ scales as $|\Pi|$ rather than $\log|\Pi|$ , which makes the algorithm prohibitively slow in practice. In what follows, we achieve similar regret rates, but with faster algorithms.
Connection to a classification problem. We make a connection to a well-studied classification problem in âtraditionalâ machine learning. This connection leads to faster algorithms, and is probably the main motivation for the setting of contextual bandits with policy sets.
To build up the intuition, let us consider the full-feedback version of contextual bandits, in which the rewards are observed for all arms.
Problem protocol: Contextual bandits with full feedback
For each round $t=1,2,...$ :
- algorithm observes a âcontextâ $x_{t}$ ,
- algorithm picks an arm $a_{t}$ ,
- rewards $\tilde{r}_{t}(a)â„ 0$ are observed for all arms $aâ\mathcal{A}$ .
In fact, let us make the problem even easier. Suppose we already have $N$ data points of the form $(x_{t};\tilde{r}_{t}(a):aâ\mathcal{A})$ . What is the âbest-in-hindsightâ policy for this dataset? More precisely, what is a policy $\piâ\Pi$ with a largest realized policy value
$$
\displaystyle\tilde{r}(\pi)=\frac{1}{N}\sum_{t=1}^{N}\tilde{r}_{t}(\pi(x_{i})). \tag{109}
$$
This happens to be a well-studied problem called âcost-sensitive multi-class classificationâ:
Problem: Cost-sensitive multi-class classification for policy class $\Pi$
Given: data points $(x_{t};\tilde{r}_{t}(a):aâ\mathcal{A})$ , $tâ[N]$ . Find: policy $\piâ\Pi$ with a largest realized policy value (109).
In the terminology of classification problems, each context $x_{t}$ is an âexampleâ, and the arms correspond to different possible âlabelsâ for this example. Each label has an associated reward/cost. We obtain a standard binary classification problem if for each data point $t$ , there is one âcorrect labelâ with reward $1$ , and rewards for all other labels are $0$ . The practical motivation for finding the âbest-in-hindsightâ policy is that it is likely to be a good policy for future context arrivals. In particular, such policy is near-optimal under the IID assumption, see Exercise 8.2 for a precise formulation.
An algorithm for this problem will henceforth be called a classification oracle for policy class $\Pi$ . While the exact optimization problem is NP-hard for many natural policy classes, practically efficient algorithms exist for several important policy classes such as linear classifiers, decision trees and neural nets.
A very productive approach for designing contextual bandit algorithms uses a classification oracle as a subroutine. The running time is then expressed in terms of the number of oracle calls, the implicit assumption being that each oracle call is reasonably fast. Crucially, algorithms can use any available classification oracle; then the relevant policy class $\Pi$ is simply the policy class that the oracle optimizes over.
A simple oracle-based algorithm. Consider a simple explore-then-exploit algorithm that builds on a classification oracle. First, we explore uniformly for the first $N$ rounds, where $N$ is a parameter. Each round $t$ of exploration gives a data point $(x_{t},\tilde{r}_{t}(a)â\mathcal{A})$ for the classification oracle, where the âfake rewardsâ $\tilde{r}_{t}(·)$ are given by inverse propensity scoring:
$$
\displaystyle\tilde{r}_{t}(a)=\begin{cases}r_{t}K&\text{if }a=a_{t}\\
0,&\text{otherwise}.\end{cases} \tag{110}
$$
We call the classification oracle and use the returned policy in the remaining rounds; see Algorithm 3.
Parameter: exploration duration $N$ , classification oracle $\mathcal{O}$
1. Explore uniformly for the first $N$ rounds: in each round, pick an arm u.a.r.
1. Call the classification oracle with data points $(x_{t},\tilde{r}_{t}(a)â\mathcal{A})$ , $tâ[N]$ as per Eq. (110).
1. Exploitation: in each subsequent round, use the policy $\pi_{0}$ returned by the oracle.
Algorithm 3 Explore-then-exploit with a classification oracle
**Remark 8.7**
*Algorithm 3 is modular in two ways: it can take an arbitrary classification oracle, and it can use any other unbiased estimator instead of Eq. (110). In particular, the proof below only uses the fact that Eq. (110) is an unbiased estimator with $\tilde{r}_{t}(a)†K$ .*
For a simple analysis, assume that the rewards are in $[0,1]$ and that the oracle is exact, in the sense that it returns a policy $\piâ\Pi$ that exactly maximizes $\mu(\pi)$ .
**Theorem 8.8**
*Let $\mathcal{O}$ be an exact classification oracle for some policy class $\Pi$ . Algorithm 3 parameterized with oracle $\mathcal{O}$ and $N=T^{2/3}(K\log(|\Pi|T))^{\frac{1}{3}}$ has regret
$$
\operatornamewithlimits{\mathbb{E}}[R_{\Pi}(T)]=O(T^{2/3})(K\log(|\Pi|T))^{\frac{1}{3}}.
$$*
This regret bound has two key features: logarithmic dependence on $|\Pi|$ and $\tilde{O}(T^{2/3})$ dependence on $T$ .
* Proof*
Let us consider an arbitrary $N$ for now. For a given policy $\pi$ , we estimate its expected reward $\mu(\pi)$ using the realized policy value from (109), where the action costs $\tilde{r}_{t}(·)$ are from (110). Let us prove that $\tilde{r}(\pi)$ is an unbiased estimate for $\mu(\pi)$ :
| | $\displaystyle\operatornamewithlimits{\mathbb{E}}[\tilde{r}_{t}(a)\mid x_{t}]$ | $\displaystyle=\mu(a\mid x_{t})$ | (for each action $aâ\mathcal{A}$ ) | |
| --- | --- | --- | --- | --- |
which implies $\operatornamewithlimits{\mathbb{E}}[\tilde{r}(\pi)]=\mu(\pi)$ , as claimed. Now, let us use this estimate to set up a âclean eventâ:
$$
\left\{\mid\tilde{r}(\pi)-\mu(\pi)\mid\leq\mathtt{conf}(N)\text{ for all policies $\pi\in\Pi$}\right\},
$$
where the confidence term is $\mathtt{conf}(N)=O(\sqrt{\frac{K\log(T|\Pi|)}{N}}).$ We can prove that the clean event does indeed happen with probability at least $1-\tfrac{1}{T}$ , say, as an easy application of Chernoff Bounds. For intuition, the $K$ is present in the confidence radius is because the âfake rewardsâ $\tilde{r}_{t}(·)$ could be as large as $K$ . The $|\Pi|$ is there (inside the $\log$ ) because we take a Union Bound across all policies. And the $T$ is there because we need the âerror probabilityâ to be on the order of $\tfrac{1}{T}$ . Let $\pi^{*}=\pi^{*}_{\Pi}$ be an optimal policy. Since we have an exact classification oracle, $\tilde{r}(\pi_{0})$ is maximal among all policies $\piâ\Pi$ . In particular, $\tilde{r}(\pi_{0})â„\tilde{r}(\pi^{*})$ . If the clean event holds, then
$$
\mu(\pi^{\star})-\mu(\pi_{0})\leq 2\,\mathtt{conf}(N).
$$
Thus, each round in exploitation contributes at most $\mathtt{conf}$ to expected regret. And each round of exploration contributes at most $1$ . It follows that $\operatornamewithlimits{\mathbb{E}}[R_{\Pi}(T)]†N+2T\,\mathtt{conf}(N)$ . Choosing $N$ so that $N=O(T\,\mathtt{conf}(N))$ , we obtain $N=T^{2/3}(K\log(|\Pi|T))^{\frac{1}{3}}$ and $\operatornamewithlimits{\mathbb{E}}[R_{\Pi}(T)]=O(N)$ . â
**Remark 8.9**
*If the oracle is only approximate â say, it returns a policy $\pi_{0}â\Pi$ which optimizes $c(·)$ up to an additive factor of $\epsilon$ â it is easy to see that expected regret increases by an additive factor of $\epsilon T$ . In practice, there may be a tradeoff between the approximation guarantee $\epsilon$ and the running time of the oracle.*
**Remark 8.10**
*A near-optimal regret bound can in fact be achieved with an oracle-efficient algorithm: one that makes only a small number of oracle calls. Specifically, one can achieve regret $O(\sqrt{KT\log(T|\Pi|)})$ with only $\tilde{O}(\sqrt{KT/\log|\Pi|})$ oracle calls across all $T$ rounds. This sophisticated result can be found in (Agarwal et al., 2014). Its exposition is beyond the scope of this book.*
45 Learning from contextual bandit data
Data collected by a contextual bandit algorithm can be analyzed âofflineâ, separately from running the algorithm. Typical tasks are estimating the value of a given policy (policy evaluation), and learning a policy that performs best on the dataset (policy training). While these tasks are formulated in the terminology from Section 44, they are meaningful for all settings discussed in this chapter.
Let us make things more precise. Assume that a contextual bandit algorithm has been running for $T$ rounds according to the following extended protocol:
Problem protocol: Contextual bandit data collection
For each round $tâ[N]$ :
- algorithm observes a âcontextâ $x_{t}$ ,
- algorithm picks a sampling distribution $p_{t}$ over arms,
- arm $a_{t}$ is drawn independently from distribution $p_{t}$ ,
- rewards $\tilde{r}_{t}(a)$ are realized for all arms $aâ\mathcal{A}$ ,
- reward $r_{t}=\tilde{r}_{t}(a_{t})â[0,1]$ is recorded.
Thus, we have $N$ data points of the form $(x_{t},p_{t},a_{t},r_{t})$ . The sampling probabilities $p_{t}$ are essential to form the IPS estimates, as explained below. It is particularly important to record the sampling probability for the chosen action, $p_{t}(a_{t})$ . Policy evaluation and training are defined as follows:
Problem: Policy evaluation and training
Input: data points $(x_{t},p_{t},a_{t},r_{t})$ , $tâ[N]$ . Policy evaluation: estimate policy value $\mu(\pi)$ for a given policy $\pi$ . Policy training: find policy $\piâ\Pi$ that maximizes $\mu(\pi)$ over a given policy class $\Pi$ .
Inverse propensity scoring. Policy evaluation can be addressed via inverse propensity scoring (IPS), like in Algorithm 3. This approach is simple and does not rely on a particular model of the rewards such as linearity or Lipschitzness. We estimate the value of each policy $\pi$ as follows:
$$
\displaystyle\mathtt{IPS}(\pi)=\sum_{t\in[N]:\;\pi(x_{t})=a_{t}}\;\frac{r_{t}}{p_{t}(a_{t})}. \tag{111}
$$
Just as in the proof of Theorem 8.8, one can show that the IPS estimator is unbiased and accurate; accuracy holds with probability as long as the sampling probabilities are large enough.
**Lemma 8.11**
*The IPS estimator is unbiased: $\operatornamewithlimits{\mathbb{E}}\left[\,\mathtt{IPS}(\pi)\,\right]=\mu(\pi)$ for each policy $\pi$ . Moreover, the IPS estimator is accurate with high probability: for each $\delta>0$ , with probability at least $1-\delta$
$$
\displaystyle|\mathtt{IPS}(\pi)-\mu(\pi)|\leq O\left(\sqrt{\tfrac{1}{p_{0}}\;\log(\tfrac{1}{\delta})/N}\right),\quad\text{where $p_{0}=\min_{t,a}p_{t}(a)$}. \tag{112}
$$*
**Remark 8.12**
*How many data points do we need to evaluate $M$ policies simultaneously? To make this question more precise, suppose we have some fixed parameters $\epsilon,\delta>0$ in mind, and want to ensure that
| | $\displaystyle\Pr\left[\;|\mathtt{IPS}(\pi)-\mu(\pi)|â€\epsilon\quad\text{for each policy $\pi$}\;\right]>1-\delta.$ | |
| --- | --- | --- |
How large should $N$ be, as a function of $M$ and the parameters? Taking a union bound over (112), we see that it suffices to take
$$
N\sim\frac{\sqrt{\log(M/\delta)}}{p_{0}\cdot\epsilon^{2}}.
$$
The logarithmic dependence on $M$ is due to the fact that each data point $t$ can be reused to evaluate many policies, namely all policies $\pi$ with $\pi(x_{t})=a_{t}$ .*
We can similarly compare $\mathtt{IPS}(\pi)$ with the realized policy value $\tilde{r}(\pi)$ , as defined in (109). This comparison does not rely on IID rewards: it applies whenever rewards are chosen by an oblivious adversary.
**Lemma 8.13**
*Assume rewards $\tilde{r}_{t}(·)$ are chosen by a deterministic oblivious adversary. Then we have $\operatornamewithlimits{\mathbb{E}}[\mathtt{IPS}(\pi)]=\tilde{r}(\pi)$ for each policy $\pi$ . Moreover, for each $\delta>0$ , with probability at least $1-\delta$ we have:
$$
\displaystyle|\mathtt{IPS}(\pi)-\tilde{r}(\pi)|\leq O\left(\sqrt{\tfrac{1}{p_{0}}\;\log(\tfrac{1}{\delta})/N}\right),\quad\text{where $p_{0}=\min_{t,a}p_{t}(a)$}. \tag{113}
$$*
This lemma implies Lemma 8.11. It easily follows from a concentration inequality, see Exercise 8.3.
Policy training can be implemented similarly: by maximizing $\mathtt{IPS}(\pi)$ over a given policy class $\Pi$ . A maximizer $\pi_{0}$ can be found by a single call to the classification oracle for $\Pi$ : indeed, call the oracle with âfake rewardsâ defined by estimates: $\rho_{t}(a)={\bf 1}_{\left\{\,a=a_{t}\,\right\}}\frac{r_{t}}{p_{t}(a_{t})}$ for each arm $a$ and each round $t$ . The performance guarantee follows from Lemma 8.13:
**Corollary 8.14**
*Consider the setting in Lemma 8.13. Fix policy class $\Pi$ and let $\pi_{0}â\operatornamewithlimits{argmax}_{\piâ\Pi}\mathtt{IPS}(\pi)$ . Then for each $\delta>0$ , with probability at least $\delta>0$ we have
$$
\displaystyle\max_{\pi\in\Pi}\tilde{r}(\pi)-\tilde{r}(\pi_{0})\leq O\left(\sqrt{\tfrac{1}{p_{0}}\;\log(\tfrac{|\Pi|}{\delta})/N}\right). \tag{114}
$$*
Model-dependent approaches. One could estimate the mean rewards $\mu(a|x)$ directly, e.g., with linear regression, and then use the resulting estimates $\hat{\mu}(a|x)$ to estimate policy values:
$$
\hat{\mu}(\pi)=\operatornamewithlimits{\mathbb{E}}_{x\sim\mathcal{D}}[\hat{\mu}(\pi(x)\mid x)].
$$
Such approaches are typically motivated by some model of rewards, e.g., linear regression is motivated by the linear model. Their validity depends on how well the data satisfies the assumptions in the model.
For a concrete example, linear regression based on the model in Section 43 constructs estimates $\hat{\theta}_{a}$ for latent vector $\theta_{a}$ , for each arm $a$ . Then rewards are estimated as $\hat{\mu}(a|x)=x·\theta_{a}$ .
Model-dependent reward estimates can naturally be used for policy optimization:
$$
\pi(x)=\operatornamewithlimits{argmax}_{a\in\mathcal{A}}\hat{\mu}(a|x).
$$
Such policy can be good even if the underlying model is not. No matter how a policy is derived, it can be evaluated in a model-independent way using the IPS methodology described above.
46 Contextual bandits in practice: challenges and a system design
Implementing contextual bandit algorithms for large-scale applications runs into a number of engineering challenges and necessitates a design of a system along with the algorithms. We present a system for contextual bandits, called the Decision Service, building on the machinery from the previous two sections.
The key insight is the distinction between the front-end of the system, which directly interacts with users and needs to be extremely fast, and the back-end, which can do more powerful data processing at slower time scales. Policy execution, computing the action given the context, must happen in the front-end, along with data collection (logging). Policy evaluation and training usually happen in the back-end. When a better policy is trained, it can be deployed into the front-end. This insight leads to a particular methodology, organized as a loop in Figure 4. Let us discuss the four components of this loop in more detail.
<details>
<summary>figures/ch-CB-loop.png Details</summary>
### Visual Description
# Technical Document Extraction: Iterative Process Diagram
## 1. Image Overview
The image is a technical process diagram representing a continuous, four-stage circular lifecycle. The diagram uses a lime-green color scheme for both text and graphical elements against a light gray background.
## 2. Component Isolation
The diagram is structured as a circle divided into four equal quadrants by a central cross-hair (vertical and horizontal white space). Each quadrant contains a text label and is bordered by an outer curved arrow indicating the direction of the flow.
### Region: Top-Right Quadrant
* **Text Label:** `Explore`
* **Directional Element:** A curved green arrow on the outer edge pointing downward (clockwise).
* **Spatial Placement:** [x: 75%, y: 25%]
### Region: Bottom-Right Quadrant
* **Text Label:** `Log`
* **Directional Element:** A curved green arrow on the outer edge pointing leftward (clockwise).
* **Spatial Placement:** [x: 75%, y: 75%]
### Region: Bottom-Left Quadrant
* **Text Label:** `Learn`
* **Directional Element:** A curved green arrow on the outer edge pointing upward (clockwise).
* **Spatial Placement:** [x: 25%, y: 75%]
### Region: Top-Left Quadrant
* **Text Label:** `Deploy`
* **Directional Element:** A curved green arrow on the outer edge pointing rightward (clockwise).
* **Spatial Placement:** [x: 25%, y: 25%]
## 3. Process Flow and Logic
The diagram illustrates a clockwise iterative loop. Based on the arrow placements and standard process modeling, the sequence is as follows:
1. **Explore:** The initial phase of investigation or discovery.
2. **Log:** The phase of recording data, observations, or results from the exploration.
3. **Learn:** The analytical phase where logged data is processed to gain insights.
4. **Deploy:** The implementation phase where learnings are put into practice, leading back to a new "Explore" phase.
## 4. Textual Transcription
| Quadrant | Text |
| :--- | :--- |
| Top-Left | **Deploy** |
| Top-Right | **Explore** |
| Bottom-Right | **Log** |
| Bottom-Left | **Learn** |
## 5. Visual Specifications
* **Color Palette:** Lime Green (Hex approx: #84BD00) for text and arrows; White for quadrant backgrounds; Light Gray for the overall image background.
* **Shape:** Circular, segmented into four quadrants.
* **Arrow Style:** Thick, curved arrows with triangular heads, following the outer circumference of the circle.
</details>
Figure 4: The learning loop.
Exploration
Actions are chosen by the exploration policy: a fixed policy that runs in the front-end and combines exploration and exploitation. Conceptually, it takes one or more default policies as subroutines, and adds some exploration on top. A default policy is usually known to be fairly good; it could be a policy already deployed in the system and/or trained by a machine learning algorithm. One basic exploration policy is $\epsilon$ -greedy: choose an action uniformly at random with probability $\epsilon$ (âexploration branchâ), and execute the default policy with the remaining probability (âexploitation branchâ). If several default policies are given, the exploitation branch chooses uniformly at random among them; this provides an additional layer of exploration, as the default policies may disagree with one another.
If a default policy is based on a score predictor $\nu(a|x)$ , as in Example 8.5, an exploration policy can give preference to actions with higher scores. One such exploration policy, known as SoftMax, assigns to each action $a$ the probability proportional to $e^{\tau·\nu(a|x)}$ , where $\tau$ is the exploration parameter. Note that $\tau=0$ corresponds to the uniform action selection, and increasing the $\tau$ favors actions with higher scores. Generically, exploration policy is characterized by its type (e.g., $\epsilon$ -greedy or SoftMax), exploration parameters (such as the $\epsilon$ or the $\tau$ ), and the default policy/policies. Logging
Logging runs in the front-end, and records the âdata pointsâ defined in Section 45. Each logged data point includes $(x_{t},a_{t},r_{t})$ â the context, the chosen arm, and the reward â and also $p_{t}(a_{t})$ , the probability of the chosen action. Additional information may be included to help with debugging and/or machine learning, e.g., time stamp, current exploration policy, or full sampling distribution $p_{t}$ .
In a typical high-throughput application such as a website, the reward (e.g., a click) is observed long after the action is chosen â much longer than a front-end server can afford to ârememberâ a given user. Accordingly, the reward is logged separately. The decision tuple, comprising the context, the chosen action, and sampling probabilities, is recorded by the front-end when the action is chosen. The reward is logged after it is observed, probably via a very different mechanism, and joined with the decision tuple in the back-end. To enable this join, the front-end server generates a unique âtuple IDâ which is included in the decision tuple and passed along to be logged with the reward as the outcome tuple.
Logging often goes wrong in practice. The sampling probabilities $p_{t}$ may be recorded incorrectly, or accidentally included as features. Features may be stored as references to a database which is updated over time (so the feature values are no longer the ones observed by the exploration policy). When optimizing an intermediate step in a complex system, the action chosen initially might be overridden by business logic, and the recorded action might incorrectly be this final action rather than the initially chosen action. Finally, rewards may be lost or incorrectly joined to the decision tuples. Learning
Policy training, discussed in Section 45, happens in the back-end, on the logged data. The main goal is to learn a better âdefault policyâ, and perhaps also better exploration parameters. The policy training algorithm should be online, allowing fast updates when new data points are received, so as to enable rapid iterations of the learning loop in Figure 4.
Offline learning uses logged data to simulate experiments on live users. Policy evaluation, for example, simulates deploying a given policy. One can also experiment with alternative exploration policies or parameterizations thereof. Further, one can try out other algorithms for policy training, such as those that need more computation, use different hyper-parameters, are based on estimators other than IPS, or lead to different policy classes. The algorithms being tested do not need to be approved for a live deployment (which may be a big hurdle), or implemented at a sufficient performance and reliability level for the said deployment (which tends to be very expensive). Policy deployment
New default policies and/or exploration parameters are deployed into the exploration policy, thereby completing the learning loop in Figure 4. As a safeguard, one can use human oversight and/or policy evaluation to compare the new policy with others before deploying it. A standard consideration in machine learning applies: a policy should not be evaluated on the training data. Instead, a separate dataset should be set aside for policy evaluation. The deployment process should be automatic and frequent. The frequency of deployments depends on the delays in data collection and policy training, and on the need of human oversight. Also, some applications require a new default policy to improve over the old one by a statistically significant margin, which may require waiting for more data points.
The methodology described above leads to the following system design:
<details>
<summary>x2.png Details</summary>
### Visual Description
# Technical Document Extraction: Machine Learning System Architecture
## 1. Document Overview
This image is a technical architectural diagram illustrating a Reinforcement Learning (RL) or Personalization loop. It details the flow of data between a client application, an online learning system, and an offline learning pipeline.
## 2. Component Isolation
### Region A: Client Interface (Left)
* **App (Yellow Box):** Represents the end-user application.
* **Client Library or Web API (Blue Box):** The interface layer that communicates directly with the App.
* **Internal Data Flow (App â Client Library):**
* `context`: Arrow pointing from App to Client Library.
* `decision`: Arrow pointing from Client Library to App.
* `reward`: Arrow pointing from App to Client Library.
### Region B: Data Processing (Bottom Center)
* **Join Server (Blue Box):** Receives data from the Client Library.
* **Data (Green Cylinder):** A database or storage icon representing the persistence of training data.
### Region C: Learning Engines (Right/Top Center)
* **Online Learning (Blue Box):** A real-time learning component.
* **Offline Learning (Grey Box):** A batch processing or historical training component.
## 3. System Flow and Logic
The diagram describes a continuous feedback loop consisting of the following steps:
1. **Interaction Phase:**
* The **App** sends `context` to the **Client Library**.
* The **Client Library** returns a `decision` to the **App**.
* The **App** subsequently provides a `reward` based on the outcome of that decision.
2. **Data Aggregation:**
* The **Client Library** sends `Interactions` and `Rewards` to the **Join Server**.
* The **Join Server** processes these and sends `Training Data` to the **Data** storage.
3. **Learning Phase:**
* **Offline Learning:** Pulls data from the **Data** storage to train models. It outputs `Parameters` and `Models` to the **Online Learning** system.
* **Online Learning:** Receives real-time data from the **Join Server** and model updates from **Offline Learning**.
4. **Deployment Phase:**
* The **Online Learning** system identifies the `Best model` and pushes it back to the **Client Library or Web API** to inform future decisions.
## 4. Textual Transcriptions
| Label | Type | Context/Direction |
| :--- | :--- | :--- |
| **App** | Component | Primary user interface |
| **context** | Data Flow | App â Client Library |
| **decision** | Data Flow | Client Library â App |
| **reward** | Data Flow | App â Client Library |
| **Client Library or Web API** | Component | Integration layer |
| **Interactions Rewards** | Data Flow | Client Library â Join Server |
| **Join Server** | Component | Data ingestion and joining |
| **Training Data** | Data Flow | Join Server â Data Storage |
| **Data** | Component | Storage (Green Cylinder) |
| **Online Learning** | Component | Real-time model optimization |
| **Offline Learning** | Component | Batch model training |
| **Parameters Models** | Data Flow | Offline Learning â Online Learning |
| **Best model** | Data Flow | Online Learning â Client Library |
## 5. Visual/Spatial Grounding
* **Color Coding:**
* **Blue:** Active processing components (Client Library, Join Server, Online Learning).
* **Yellow:** User-facing application.
* **Grey:** Background/Batch processing (Offline Learning).
* **Green:** Data persistence.
* **Layout:** The diagram follows a circular flow. It starts at the far left (App), moves clockwise through the learning components on the right, and returns to the left via the "Best model" path. Data collection flows through the bottom center.
</details>
The front-end interacts with the application via a provided software library (âClient Libraryâ) or via an Internet-based protocol (âWeb APIâ). The Client Library implements exploration and logging, and the Web API is an alternative interface to the said library. Decision tuples and outcome tuples are joined by the Join Server, and then fed into a policy training algorithm (the âOnline Learningâ box). Offline Learning is implemented as a separate loop which can operate at much slower frequencies.
Modularity of the design is essential, so as to integrate easily with an applicationâs existing infrastructure. In particular, the components have well-defined interfaces, and admit multiple consistent implementations. This avoids costly re-implementation of existing functionality, and allows the system to improve seamlessly as better implementations become available.
Essential issues and extensions
Let discuss several additional issues and extensions that tend to be essential in applications. As a running example, consider optimization of a simple news website called $\mathtt{SimpleNews}$ . While this example is based on a successful product deployment, we ignore some real-life complications for the sake of clarity. Thus, $\mathtt{SimpleNews}$ displays exactly one headline to each user. When a user arrives, some information is available pertaining to the interaction with this particular user, e.g., age, gender, geolocation, time of day, and possibly much more; such information is summarily called the context. The website chooses a news topic (e.g., politics, sports, tech, etc.), possibly depending on the context, and the top headline for the chosen topic is displayed. The websiteâs goal is to maximize the number of clicks on the headlines that it displays. For this example, we are only concerned with the choice of news topic: that is, we want to pick a news topic whose top headline is most likely to be clicked on for a given context.
Fragmented outcomes. A good practice is to log the entire observable outcome, not just the reward. For example, the outcome of choosing a news topic in $\mathtt{SimpleNews}$ includes the dwell time: the amount of time the user spent reading a suggested article (if any). Multiple outcome fragments may arrive at different times. For example, the dwell time $\mathtt{SimpleNews}$ is recorded long after the initial click on the article. Thus, multiple outcome tuples may be logged by the front-end. If the reward depends on multiple outcome fragments, it may be computed by the Join Server after the outcome tuples are joined, rather than in the front-end.
Reward metrics. There may be several reasonable ways to define rewards, especially with fragmented outcomes. For example, in $\mathtt{SimpleNews}$ the reward can include a bonus that depends on the dwell time, and there may be several reasonable choices for defining such a bonus. Further, the reward may depend on the context, e.g., in $\mathtt{SimpleNews}$ some clicks may be more important than others, depending on the userâs demographics. Thus, a reward metric used by the application is but a convenient proxy for the long-term objective such as cumulative revenue or long-term customer satisfaction. The reward metric may change over time when priorities change or when a better proxy for the long-term objective is found. Further, it may be desirable to consider several reward metrics at once, e.g., for safeguards. Offline learning can be used to investigate the effects of switching to another reward metric in policy training.
Non-stationarity. While weâve been positing a stationarity environment so far, applications exhibit only periods of near-stationarity in practice. To cope with a changing environment, we use a continuous loop in which the policies are re-trained and re-deployed quickly as new data becomes available. Therefore, the infrastructure and the policy training algorithm should process new data points sufficiently fast. Policy training should de-emphasize older data points over time. Enough data is needed within a period of near-stationarity (so more data is needed to adapt to faster rate of change).
Non-stationarity is partially mitigated if some of it is captured by the context. For example, users of $\mathtt{SimpleNews}$ may become more interested in sports during major sports events such as Olympics. If the presence of such events is included as features in the context, the response to a particular news topic given a particular context becomes more consistent across time.
In a non-stationary environment, the goal of policy evaluation is no longer to estimate the expected reward (simply because this quantity changes over time) or predict rewards in the future. Instead, the goal is counterfactual: estimate the policyâs performance if it were used when the exploration data was collected. This is a mathematically precise goal that is achievable (say) by the IPS estimator regardless of how the environment changes in the meantime. When algorithms for exploration and/or policy training are evaluated on the exploration data, the goal is counterfactual in a similar sense. This is very useful for comparing these algorithms with alternative approaches. One hopes that such comparison on the exploration data would be predictive of a similar comparison performed via a live A/B test.
Feature selection. Selecting which features to include in the context is a fundamental issue in machine learning. Adding more features tends to lead to better rewards in the long run, but may slow down the learning. The latter could be particular damaging if the environment changes over time and fast learning is essential. The same features can be represented in different ways, e.g., a feature with multiple possible values can be represented either as one value or as a bit vector (1-hot encoding) with one bit for each possible value. Feature representation is essential, as general-purpose policy training algorithms tend to be oblivious to what features mean. A good feature representation may depend on a particular policy training algorithm. Offline learning can help investigate the effects of adding/removing features or changing their representation. For this purpose, additional observable features (not included in the context) can be logged in the decision tuple and passed along to offline learning.
Ease of adoption. Developers might give up on a new system, unless it is easy to adopt. Implementation should avoid or mitigate dependencies on particular programming languages or external libraries. The trial experience should be seamless, e.g., sensible defaults should be provided for all components.
Road to deployment
Consider a particular application such as $\mathtt{SimpleNews}$ , call it $\mathtt{APP}$ . Deploying contextual bandits for this application should follow a process, even when the contextual bandit system such as the Decision Service is available. One should do some prep-work: frame the $\mathtt{APP}$ as a contextual bandit problem, verify that enough data would be available, and have a realistic game plan for integrating the system with the existing infrastructure. Next step is a pilot deployment on a small fraction of traffic. The goal here is to validate the system for $\mathtt{APP}$ and debug problems; deep integration and various optimizations can come later. Finally, the system is integrated into $\mathtt{APP}$ , and deployed on a larger fraction of traffic.
Framing the problem. Interactions between $\mathtt{APP}$ and its users should be interpreted as a sequence of small interactions with individual users, possibly overlapping in time. Each small interaction should follow a simple template: observe a context, make a decision, choosing from the available alternatives, and observe the outcome of this decision. The meaning of contexts, decisions and outcomes should be consistent throughout. The context, typically represented as a vector of features, should encompass the properties of the current user and/or task to be accomplished, and must be known to $\mathtt{APP}$ . The decision must be controlled by $\mathtt{APP}$ . The set of feasible actions should be known: either fixed in advance or specified by the context. It is often useful to describe actions with features of their own, a.k.a. action-specific features. The outcome consists of one or several events, all of which must be observable by $\mathtt{APP}$ not too long after the action is chosen. The outcome (perhaps jointly with the context) should define a reward: the short-term objective to be optimized. Thus, one should be able to fill in the table below:
| | $\mathtt{SimpleNews}$ | Your $\mathtt{APP}$ |
| --- | --- | --- |
| Context | (gender, location, time-of-day) | |
| Decision | a news topic to display | |
| Feasible actions | {politics, sports, tech, arts} | |
| Action-specific features | none | |
| Outcome | click or no click within 20 seconds | |
| Reward | $1$ if clicked, $0$ otherwise | |
As discussed above, feature selection and reward definition can be challenging. Defining decisions and outcomes may be non-trivial, too. For example, $\mathtt{SimpleNews}$ can be modified so that actions correspond to news articles, rather than news topics, and each decision consists of choosing a slate of news articles.
Scale and feasibility. To estimate the scale and feasibility of the learning problem in $\mathtt{APP}$ , one needs to estimate a few parameters: the number of features ( $\mathtt{\#features}$ ), the number of feasible actions ( $\mathtt{\#actions}$ ), a typical delay between making a decision and observing the corresponding outcome, and the data rate: the number of experimental units per a time unit. If the outcome includes a rare event whose frequency is crucial to estimate â e.g., clicks are typically rare compared to non-clicks, â then we also need a rough estimate of this frequency. Finally, we need the stationarity timescale: the time interval during which the environment does not change too much, namely the distribution of arriving contexts (where a context includes the set of feasible actions and, if applicable, their features), and the expected rewards for each context-action pair. In the $\mathtt{SimpleNews}$ example, this corresponds to the distribution of arriving user profiles and the click probability for the top headline (for a given news topic, when presented to a typical user with a given user profile). To summarize, one should be able to fill in Table 3.
| | $\mathtt{SimpleNews}$ | Your $\mathtt{APP}$ |
| --- | --- | --- |
| $\mathtt{\#features}$ | 3 | |
| $\mathtt{\#actions}$ | 4 news topics | |
| Typical delay | 5 sec | |
| Data rate | 100 users/sec | |
| Rare event frequency | typical click prob. 2-5% | |
| Stationarity timescale | one week | |
Table 3: The scalability parameters (using $\mathtt{SimpleNews}$ as an example)
For policy training algorithms based on linear classifiers, a good rule-of-thumb is that the stationarity timescale should be much larger than the typical delay, and moreover we should have
$$
\displaystyle\mathtt{StatInterval}\times\mathtt{DataRate}\times\mathtt{RareEventFreq}\gg\mathtt{\#actions}\times\mathtt{\#features} \tag{115}
$$
The left-hand side is the number of rare events in the timescale, and the right-hand side characterizes the complexity of the learning problem.
47 Literature review and discussion
Lipschitz contextual bandits. Contextual bandits with a Lipschitz condition on contexts have been introduced in Hazan and Megiddo (2007), along with a solution via uniform discretization of contexts and, essentially, the upper bound in Theorem 8.4. The extension to the more general Lipschitz condition (103) has been observed, simultaneously and independently, in Lu et al. (2010) and Slivkins (2014). The regret bound in Exercise 8.1 is optimal in the worst case (Lu et al., 2010; Slivkins, 2014).
Adaptive discretization improves over uniform discretization, much like it does in Chapter 4. The key is to discretize the context-arms pairs, rather than contexts and arms separately. This approach is implemented in Slivkins (2014), achieving regret bounds that are optimal in the worst case, and improve for âniceâ problem instances. For precisely, there is a contextual version of the ârawâ regret bound (64) in terms of the covering numbers, and an analog of Theorem 4.18 in terms of a suitable version of the zooming dimension. Both regret bounds are essentially the best possible. This approach extends to an even more general Lipschitz condition when the right-hand side of (101) is an arbitrary metric on context-arm pairs.
Slivkins (2014) applies this machinery to handle some adversarial bandit problems. Consider the special case of Lipschitz contextual bandits when the context $x_{t}$ is simply the time $t$ (here, it is crucial that the contexts are not assumed to arrive from fixed distribution). The Lipschitz condition can be written as
$$
\displaystyle|\mu(a\mid t)-\mu(a\mid t^{\prime})|\leq\mathcal{D}_{a}(t,t^{\prime}), \tag{116}
$$
where $\mathcal{D}_{a}$ is a metric on $[T]$ that is known to the algorithm, and possibly parameterized by the arm $a$ . This condition describes a bandit problem with randomized adversarial rewards such that the expected rewards can only change slowly. The paradigmatic special cases are $\mathcal{D}_{a}(t,t^{\prime})=\sigma_{a}·|t-t^{\prime}|$ , bounded change in each round, and $\mathcal{D}_{a}(t,t^{\prime})=\sigma_{a}·\sqrt{|t-t^{\prime}|}$ . The latter case subsumes a scenario when mean rewards follow a random walk. More precisely, the mean reward of each arm $a$ evolves as a random walk with step $±\sigma_{a}$ on the $[0,1]$ interval with reflecting boundaries. For the special cases, Slivkins (2014) achieves near-optimal bounds on âdynamic regretâ (see Section 35), as a corollary of the âgenericâ machinery for adaptive discretization. In full generality, one has a metric space and a Lipschitz condition on context-arm-time triples, and the algorithm performs adaptive discretization over these triples.
Rakhlin et al. (2015); Cesa-Bianchi et al. (2017) tackle a version of Lipschitz contextual bandits in which the comparison benchmark is the best Lipschitz policy: a mapping $\pi$ from contexts to actions which satisfies $D_{\mathcal{A}}(\pi(x),\pi(x^{\prime}))†D_{\mathcal{X}}(x,x^{\prime})$ for any two contexts $x,x^{\prime}$ , where $D_{\mathcal{A}}$ and $D_{\mathcal{X}}$ are the metrics from (103). Several feedback models are considered, including bandit feedback and full feedback.
Krishnamurthy et al. (2020) consider a mash-up of Lipschitz bandits and contextual bandits with policy sets, in which the Lipschitz condition holds across arms for every given context, and regret is with respect to a given policy set. In addition to worst-case regret bounds that come from uniform discretization of the action space, Krishnamurthy et al. (2020) obtain instance-dependent regret bounds which generalize those for the zooming algorithm in Section 22. The algorithm is based on a different technique (from DudĂk et al., 2011), and is not computationally efficient.
Linear contextual bandits have been introduced in Li et al. (2010), motivated by personalized news recommendations. Algorithm $\mathtt{LinUCB}$ was defined in Li et al. (2010), and analyzed in (Chu et al., 2011; Abbasi-Yadkori et al., 2011). The original analysis in Li et al. (2010) suffers from a subtle bug, as observed in Abbasi-Yadkori et al. (2011). The gap-dependent regret bound is from Abbasi-Yadkori et al. (2011); Dani et al. (2008) obtain a similar result for static contexts. The details â how the confidence region is defined, the computational implementation, and even the algorithmâs name â differ between from one paper to another. The name $\mathtt{LinUCB}$ stems from Li et al. (2010); we find it descriptive, and use as an umbrella term for the template in Algorithm 2. Good empirical performance of LinUCB has been observed in (Krishnamurthy et al., 2016), even when the problem is not linear. The analysis of $\mathtt{LinUCB}$ in Abbasi-Yadkori et al. (2011) extends to a more general formulation, where the action set can be infinite and time-dependent. Specifically, the action set in a given round $t$ is a bounded subset $D_{t}â[0,1]^{d}$ , so that each arm $aâ D_{t}$ is identified with its feature vector: $\theta_{a}=a$ ; the context in round $t$ is simply $D_{t}$ .
The version with âstatic contextsâ (i.e., stochastic linear bandits) has been introduced in Auer (2002). The non-contextual version of $\mathtt{LinUCB}$ was suggested in Auer (2002), and analyzed in Dani et al. (2008). Auer (2002), as well Abe et al. (2003) and Rusmevichientong and Tsitsiklis (2010), present and analyze other algorithms for this problem which are based on the same paradigm of âoptimism under uncertaintyâ, but do not fall under $\mathtt{LinUCB}$ template.
If contexts are sufficiently âdiverseâ, e.g., if they come from a sufficiently âdiffuseâ distribution, then greedy (exploitation-only) algorithm work quite well. Indeed, it achieves the $\tilde{O}(\sqrt{KT})$ regret rate, which optimal in the worst case (Bastani et al., 2021; Kannan et al., 2018). Even stronger guarantees are possible if the unknown vector $\theta$ comes from a Bayesian prior with a sufficiently large variance, and one is interested in the Bayesian regret, i.e., regret in expectation over this prior (Raghavan et al., 2023). The greedy algorithm matches the best possible Bayesian regret for a given problem instance, and is at most $\tilde{O}_{K}(T^{1/3})$ in the worst case. Moreover, $\mathtt{LinUCB}$ achieves Bayesian regret $\tilde{O}_{K}(T^{1/3})$ under the same assumptions.
Contextual bandits with policy classes. Theorem 8.6 is from Auer et al. (2002b), and the complimentary lower bound (108) is due to Agarwal et al. (2012). The oracle-based approach to contextual bandits was proposed in Langford and Zhang (2007), with an âepsilon-greedyâ-style algorithm and regret bound similar to those in Theorem 8.8. DudĂk et al. (2011) obtained a near-optimal regret bound, $O(\sqrt{KT\log(T|\Pi|)})$ , via an algorithm that is oracle-efficient âin theoryâ. This algorithm makes $\operatornamewithlimits{poly}(T,K,\log|\Pi|)$ oracle calls and relies on the ellipsoid algorithm. Finally, a break-through result of (Agarwal et al., 2014) achieved the same regret bound via a âtrulyâ oracle-efficient algorithm which makes only $\tilde{O}(\sqrt{KT/\log|\Pi|})$ oracle calls across all $T$ rounds. Krishnamurthy et al. (2016) extend this approach to combinatorial semi-bandits.
Another recent break-through extends oracle-efficient contextual bandits to adversarial rewards (Syrgkanis et al., 2016a; Rakhlin and Sridharan, 2016; Syrgkanis et al., 2016b). The optimal regret rate for this problem is not yet settled: in particular, the best current upper bound has $\tilde{O}(T^{2/3})$ dependence on $T$ , against the $\Omega(\sqrt{T})$ lower bound in Eq. (108).
Luo et al. (2018); Chen et al. (2019) design oracle-efficient algorithms with data-dependent bounds on dynamic regret (see the discussion of dynamic regret in Section 35). The regret bounds are in terms of the number of switches $S$ and the total variation $V$ , where $S$ and $V$ could be unknown, matching the regret rates (in terms of $S,V,T$ ) for the non-contextual case.
Classification oracles tend to be implemented via heuristics in practice (Agarwal et al., 2014; Krishnamurthy et al., 2016), since the corresponding classification problems are NP-hard for all/most policy classes that one would consider. However, the results on oracle-based contextual bandit algorithms (except for the $\epsilon$ -greedy-based approach) do not immediately extend to approximate classification oracles. Moreover, the oracleâs performance in practice does not necessarily carry over to its performance inside a contextual bandit algorithm, as the latter typically calls the oracle on carefully constructed artificial problem instances.
Contextual bandits with realizability. Instead of a linear model, one could posit a more abstract assumption of realizability: that the expected rewards can be predicted perfectly by some function $\mathcal{X}Ă\mathcal{A}â[0,1]$ , called regressor, from a given class $\mathcal{F}$ of regressors. This assumption leads to improved performance, in a strong provable sense, even though the worst-case regret bounds cannot be improved (Agarwal et al., 2012). One could further assume the existence of a regression oracle for $\mathcal{F}$ : a computationally efficient algorithm which finds the best regressor in $\mathcal{F}$ for a given dataset. A contextual bandit algorithm can use such oracle as a subroutine, similarly to using a classification oracle for a given policy class (Foster et al., 2018; Foster and Rakhlin, 2020; Simchi-Levi and Xu, 2020). Compared to classification oracles, regression oracles tend to be computationally efficient without any assumptions, both in theory and in practice.
Offline learning. âOfflineâ learning from contextual bandit data is a well-established approach initiated in Li et al. (2011), and further developed in subsequent work, (e.g., DudĂk et al., 2012, 2014; Swaminathan and Joachims, 2015; Swaminathan et al., 2017). In particular, DudĂk et al. (2014) develops doubly-robust estimators which, essentially, combine the benefits of IPS and model-based approaches; DudĂk et al. (2012) consider non-stationary policies (i.e., algorithms); Swaminathan et al. (2017) consider policies for âcombinatorialâ actions, where each action is a slate of âatomsâ.
Practical aspects. The material in Section 46 is adapted from (Agarwal et al., 2016, 2017b). The Decision Service, a system for large-scale applications of contextual bandits, is available at GitHub. https://github.com/Microsoft/mwt-ds/. At the time of this writing, the system is deployed at various places inside Microsoft, and is offered externally as a Cognitive Service on Microsoft Azure. https://docs.microsoft.com/en-us/azure/cognitive-services/personalizer/. The contextual bandit algorithms and some of the core functionality is provided via Vowpal Wabbit, https://vowpalwabbit.org/. an open-source library for machine learning.
Bietti et al. (2021) compare the empirical performance of various contextual bandit algorithms. Li et al. (2015) provide a case study of policy optimization and training in web search engine optimization.
48 Exercises and hints
**Exercise 8.1 (Lipschitz contextual bandits)**
*Consider the Lipschitz condition in (103). Design an algorithm with regret bound $\tilde{O}(T^{(d+1)/(d+2})$ , where $d$ is the covering dimension of $\mathcal{X}Ă\mathcal{A}$ . Hint: Extend the uniform discretization approach, using the notion of $\epsilon$ -mesh from Definition 4.4. Fix an $\epsilon$ -mesh $S_{\mathcal{X}}$ for $(\mathcal{X},\mathcal{D}_{\mathcal{X}})$ and an $\epsilon$ -mesh $S_{\mathcal{A}}$ for $(\mathcal{A},\mathcal{D}_{\mathcal{A}})$ , for some $\epsilon>0$ to be chosen in the analysis. Fix an optimal bandit algorithm $\mathtt{ALG}$ such as $\mathtt{UCB1}$ , with $S_{\mathcal{A}}$ as a set of arms. Run a separate copy $\mathtt{ALG}_{x}$ of this algorithm for each context $xâ S_{\mathcal{X}}$ .*
**Exercise 8.2 (Empirical policy value)**
*Prove that realized policy value $\tilde{r}(\pi)$ , as defined in (109), is close to the policy value $\mu(\pi)$ . Specifically, observe that $\operatornamewithlimits{\mathbb{E}}[\tilde{r}(\pi)]=\mu(\pi)$ . Next, fix $\delta>0$ and prove that
| | $\displaystyle|\mu(\pi)-\tilde{r}(\pi)|â€\mathtt{conf}(N)\quad\text{with probability at least $1-\delta/|\Pi|$},$ | |
| --- | --- | --- |
where the confidence term is $\mathtt{conf}(N)=O\left(\,\sqrt{\nicefrac{{1}}{{N}}·\log(|\Pi|/\delta)}\,\right)$ . Letting $\pi_{0}$ be the policy with a largest realized policy value, it follows that
| | $\displaystyle\max_{\piâ\Pi}\mu(\pi)-\mu(\pi_{0})$ | $\displaystyleâ€\mathtt{conf}(N)\quad\text{with probability at least $1-\delta$}$ | |
| --- | --- | --- | --- |*
**Exercise 8.3 (Policy evaluation)**
*Use Bernstein Inequality to prove Lemma 8.13. In fact, prove a stronger statement: for each policy $\pi$ and each $\delta>0$ , with probability at least $1-\delta$ we have:
$$
\displaystyle|\mathtt{IPS}(\pi)-\tilde{r}(\pi)|\leq O\left(\sqrt{V\;\log(\nicefrac{{1}}{{\delta}})/N}\right),\quad\text{where }V=\max_{t}\sum_{a\in\mathcal{A}}\frac{1}{p_{t}(a)}. \tag{117}
$$*
Chapter 9 Bandits and Games
This chapter explores connections between bandit algorithms and game theory. We consider a bandit algorithm playing a repeated zero-sum game against an adversary (e.g., another bandit algorithm). We are interested in convergence to an equilibrium: whether, in which sense, and how fast this happens. We present a sequence of results in this direction, focusing on best-response and regret-minimizing adversaries. Our analysis also yields a self-contained proof of von Neumannâs âMinimax Theoremâ. We also present a simple result for general games.
Prerequisites: Chapters 5, 6.
Throughout this chapter, we consider the following setup. A bandit algorithm $\mathtt{ALG}$ plays a repeated game against another algorithm, called an adversary and denoted $\mathtt{ADV}$ . The game is characterized by a matrix $M$ , and proceeds over $T$ rounds. In each round $t$ of the game, $\mathtt{ALG}$ chooses row $i_{t}$ of $M$ , and $\mathtt{ADV}$ chooses column $j_{t}$ of $M$ . They make their choices simultaneously, i.e., without observing each other. The corresponding entry $M(i_{t},j_{t})$ specifies the cost for $\mathtt{ALG}$ . After the round, $\mathtt{ALG}$ observes the cost $M(i_{t},j_{t})$ and possibly some auxiliary feedback. Thus, the problem protocol is as follows:
Problem protocol: Repeated game between an algorithm and an adversary
In each round $tâ 1,2,3\,,\ ...\ ,T$ :
1. Simultaneously, $\mathtt{ALG}$ chooses a row $i_{t}$ of $M$ , and $\mathtt{ADV}$ chooses a column $j_{t}$ of $M$ .
1. $\mathtt{ALG}$ incurs cost $M(i_{t},j_{t})$ , and observes feedback $\mathcal{F}_{t}=\mathcal{F}(t,i_{t},j_{t},M)$ , where $\mathcal{F}$ is a fixed and known feedback function.
We are mainly interested in two feedback models:
| | $\displaystyle\mathcal{F}_{t}$ | $\displaystyle=M(i_{t},j_{t})$ | $\displaystyle\text{\emph{(bandit feedback)}},$ | |
| --- | --- | --- | --- | --- |
However, all results in this chapter hold for an arbitrary feedback function $\mathcal{F}$ .
$\mathtt{ALG}$ âs objective is to minimize its total cost, $\mathtt{cost}(\mathtt{ALG})=\textstyle\sum_{t=1}^{T}M(i_{t},j_{t})$ .
We consider zero-sum games, unless noted otherwise, as the corresponding theory is well-developed and has rich applications. Formally, we posit that $\mathtt{ALG}$ âs cost in each round $t$ is also $\mathtt{ADV}$ âs reward. In standard game-theoretic terms, each round is a zero-sum game between $\mathtt{ALG}$ and $\mathtt{ADV}$ , with game matrix $M$ . Equivalently, $\mathtt{ALG}$ and $\mathtt{ADV}$ incur costs $M(i_{t},j_{t})$ and $-M(i_{t},j_{t})$ , respectively. Hence the term âzero-sum gameâ.
Regret assumption. The only property of $\mathtt{ALG}$ that we will rely on is its regret. Specifically, we consider a bandit problem with the same feedback model $\mathcal{F}$ , and for this bandit problem we consider regret $R(T)$ against an adaptive adversary, relative to the best-observed arm, as defined in Chapter 25. All results in this chapter are meaningful even if we only control expected regret $\operatornamewithlimits{\mathbb{E}}[R(T)]$ , more specifically if $\operatornamewithlimits{\mathbb{E}}[R(t)]=o(t)$ . Recall that this property is satisfied by algorithm $\mathtt{Hedge}$ for full feedback, and algorithm $\mathtt{Exp3}$ for bandit feedback, as per Chapters 27 and 6).
Let us recap the definition of $R(T)$ . Using the terminology from Chapter 25, the algorithmâs cost for choosing row $i$ in round $t$ is $c_{t}(i)=M(i,j_{t})$ . Let $\mathtt{cost}(i)=\sum_{t=1}^{T}c_{t}(i)$ be the total cost for always choosing row $i$ , under the observed costs $c_{t}(·)$ . Then
$$
\mathtt{cost}^{*}:=\min_{\text{rows $i$}}\mathtt{cost}(i)
$$
is the cost of the âbest observed armâ. Thus, as per Eq. (73),
$$
\displaystyle R(T)=\mathtt{cost}(\mathtt{ALG})-\mathtt{cost}^{*}. \tag{118}
$$
This is what we will mean by regret throughout this chapter.
Motivation. At face value, the setting in this chapter is about a repeated game between agents that use regret-minimizing algorithms. Consider algorithms for âactualâ games such as chess, go, or poker. Such algorithm can have a âconfigurationâ that can be tuned over time by a regret-minimizing âmeta-algorithmâ (which interprets configurations as actions, and wins/losses as payoffs). Further, agents in online commerce, such as advertisers in an ad auction and sellers in a marketplace, engage in repeated interactions such that each interaction proceeds as a game between agents according to some fixed rules, depending on bids, prices, or other signals submitted by the agents. An agent may adjust its behavior in this environment using a regret-minimizing algorithm. (However, the resulting repeated game is not zero-sum.)
Our setting, and particularly Theorem 9.5 in which both $\mathtt{ALG}$ and $\mathtt{ADV}$ minimize regret, is significant in several other ways. First, it leads to an important prediction about human behavior: namely, humans would approximately arrive at an equilibrium if they behave so as to minimize regret (which is a plausible behavioural model). Second, it provides a way to compute an approximate Nash equilibrium for a given game matrix. Third, and perhaps most importantly, the repeated game serves as a subroutine for a variety of algorithmic problems, see Section 53 for specific pointers. In particular, such subroutine is crucial for a bandit problem discussed in Chapter 10.
49 Basics: guaranteed minimax value
Game theory basics. Imagine that the game consists of a single round, i.e., $T=1$ . Let $\Delta_{\mathtt{rows}}$ and $\Delta_{\mathtt{cols}}$ denote the set of all distributions over rows and colums of $M$ , respectively. Let us extend the notation $M(i,j)$ to distributions over rows/columns: for any $pâ\Delta_{\mathtt{rows}},qâ\Delta_{\mathtt{cols}}$ , we define
| | $\displaystyle M(p,q):=\operatornamewithlimits{\mathbb{E}}_{i\sim p,\,jâ q}\left[\,M(i,j)\,\right]=p^{âp}Mq,$ | |
| --- | --- | --- |
where distributions are interpreted as column vectors.
Suppose $\mathtt{ALG}$ chooses a row from some distribution $pâ\Delta_{\mathtt{rows}}$ known to the adversary. Then the adversary can choose a distribution $qâ\Delta_{\mathtt{cols}}$ so as to maximize its expected reward $M(p,q)$ . (Any column $j$ in the support of $q$ would maximize $M(p,·)$ , too.) Accordingly, the algorithm should choose $p$ so as to minimize its maximal cost,
$$
\displaystyle f(p):=\sup_{q\in\Delta_{\mathtt{cols}}}M(p,q)=\max_{\text{columns $j$}}\;M(p,j). \tag{119}
$$
A distribution $p=p^{*}$ that minimizes $f(p)$ exactly is called a minimax strategy. At least one such $p^{*}$ exists, as an $\operatornamewithlimits{argmin}$ of a continuous function on a closed and bounded set. A minimax strategy achieves cost
| | $\displaystyle v^{*}=\min_{pâ\Delta_{\mathtt{rows}}}\;\max_{qâ\Delta_{\mathtt{cols}}}\;M(p,q),$ | |
| --- | --- | --- |
called the minimax value of the game $M$ . Note that $p^{*}$ guarantees cost at most $v^{*}$ against any adversary:
$$
\displaystyle M(p^{*},j)\leq v^{*}\quad\forall\;\text{column $j$}. \tag{120}
$$
Arbitrary adversary. We apply the regret property of the algorithm and deduce that algorithmâs expected average costs are approximately at least as good as the minimax value $v^{*}$ . Indeed,
| | $\displaystyle\mathtt{cost}^{*}=\min_{\text{rows $i$}}\mathtt{cost}(i)â€\operatornamewithlimits{\mathbb{E}}_{i\sim p^{*}}\left[\,\mathtt{cost}(i)\,\right]=\textstyle\sum_{t=1}^{T}M(p^{*},j_{t})†T\,v^{*}.$ | |
| --- | --- | --- |
Recall that $p^{*}$ is the minimax strategy, and the last inequality follows by Eq. (120). By definition of regret, we have:
**Theorem 9.1**
*For an arbitrary adversary $\mathtt{ADV}$ it holds that
$$
\tfrac{1}{T}\,\mathtt{cost}(\mathtt{ALG})\leq v^{*}+R(T)/T.
$$*
In particular, if we (only) posit sublinear expected regret, $\operatornamewithlimits{\mathbb{E}}[R(t)]=o(t)$ , then the expected average cost $\tfrac{1}{T}\,\operatornamewithlimits{\mathbb{E}}[\mathtt{cost}(\mathtt{ALG})]$ is asymptotically upper-bounded by $v^{*}$ .
Best-response adversary. Assume a specific (and very powerful) adversary called the best-response adversary. Such adversary operates as follows: in each round $t$ , it chooses a column $j_{t}$ which maximizes its expected reward given the history
$$
\displaystyle\mathcal{H}_{t}:=\left(\;(i_{1},j_{1})\,,\ \ldots\ ,(i_{t-1},j_{t-1})\;\right), \tag{121}
$$
which encompasses what happened in the previous rounds. In a formula,
$$
\displaystyle j_{t}=\min\left(\operatornamewithlimits{argmax}_{\text{columns $j$}}\operatornamewithlimits{\mathbb{E}}\,[M(i_{t},j)\mid\mathcal{H}_{t}\,]\right), \tag{122}
$$
where the expectation is over the algorithmâs choice of row $i_{t}$ . Note that the column $j$ in the $\operatornamewithlimits{argmax}$ need not be unique, hence the $\min$ in front of the $\operatornamewithlimits{argmax}$ . Any other tie-breaking rule would work, too. Such column $j$ also maximizes the expected reward $\operatornamewithlimits{\mathbb{E}}\,[M(i_{t},·)\mid\mathcal{H}_{t}\,]$ over all distributions $qâ\Delta_{\mathtt{cols}}$ .
We consider the algorithmâs average play (we give an abstract definition which we reuse later).
**Definition 9.2**
*The average play of a given bandit algorithm (up to time $T$ ) is a distribution $D$ over arms such that for each arm $a$ , the coordinate $D(a)$ is the fraction of rounds in which this arm is chosen.*
Thus, let $\bar{\imath}â\Delta_{\mathtt{rows}}$ be the algorithmâs average play. It is useful to represent it as a vector over the rows and write $\bar{\imath}:=\tfrac{1}{T}\sum_{tâ[T]}\mathbf{e}^{\mathtt{row}}_{i_{t}}$ , where $\mathbf{e}^{\mathtt{row}}_{i}$ is the $i$ -th unit vector over rows. We argue that the expected average play, $\operatornamewithlimits{\mathbb{E}}[\bar{\imath}]$ , performs well against an arbitrary column $j$ . This is easy to prove:
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}[M(i_{t},\,j)] \displaystyle=\operatornamewithlimits{\mathbb{E}}[\;\operatornamewithlimits{\mathbb{E}}[M(i_{t},\,j)\mid\mathcal{H}_{t}]\;] \displaystyle\leq\operatornamewithlimits{\mathbb{E}}[\;\operatornamewithlimits{\mathbb{E}}[M(i_{t},\,j_{t})\mid\mathcal{H}_{t}]\;] \displaystyle=\operatornamewithlimits{\mathbb{E}}[M(i_{t},\,j_{t})] \displaystyle M(\,\operatornamewithlimits{\mathbb{E}}[\bar{\imath}],j\,) \displaystyle=\textstyle\frac{1}{T}\sum_{t=1}^{T}\operatornamewithlimits{\mathbb{E}}[M(i_{t},\,j)] \displaystyle\leq\textstyle\frac{1}{T}\sum_{t=1}^{T}\operatornamewithlimits{\mathbb{E}}[\;M(i_{t},j_{t})\;] \displaystyle=\tfrac{1}{T}\operatornamewithlimits{\mathbb{E}}[\mathtt{cost}(\mathtt{ALG})]. \tag{123}
$$
Plugging this into Theorem 9.1, we prove the following:
**Theorem 9.3**
*If $\mathtt{ADV}$ is the best-response adversary, as in (122), then
$$
M(\,\operatornamewithlimits{\mathbb{E}}[\bar{\imath}],q\,)\leq\tfrac{1}{T}\,\operatornamewithlimits{\mathbb{E}}[\mathtt{cost}(\mathtt{ALG})]\leq v^{*}+\operatornamewithlimits{\mathbb{E}}[R(T)]/T\qquad\forall q\in\Delta_{\mathtt{cols}}.
$$*
Thus, if $\operatornamewithlimits{\mathbb{E}}[R(t)]=o(t)$ then $\mathtt{ALG}$ âs expected average play $\operatornamewithlimits{\mathbb{E}}[\bar{\imath}]$ asymptotically achieves the minimax property of $p^{*}$ , as expressed by Eq. (120).
50 The minimax theorem
A fundamental fact about the minimax value is that it equals the maximin value:
$$
\displaystyle\min_{p\in\Delta_{\mathtt{rows}}}\;\max_{q\in\Delta_{\mathtt{cols}}}\;M(p,q)=\max_{q\in\Delta_{\mathtt{cols}}}\;\min_{p\in\Delta_{\mathtt{rows}}}\;M(p,q). \tag{124}
$$
In other words, the $\max$ and the $\min$ can be switched. The maximin value is well-defined, in the sense that the $\max$ and the $\min$ exist, for the same reason as they do for the minimax value.
The maximin value emerges naturally in the single-round game if one switches the roles of $\mathtt{ALG}$ and $\mathtt{ADV}$ so that the former controls the columns and the latter controls the rows (and $M$ represents algorithmâs rewards rather than costs). Then a maximin strategy â a distribution $q=q^{*}â\Delta_{\mathtt{cols}}$ that maximizes the right-hand size of (124) â arises as the algorithmâs best response to a best-responding adversary. Moreover, we have an analog of Eq. (120):
$$
\displaystyle M(p,q^{*})\geq v^{\sharp}\quad\forall p\in\Delta_{\mathtt{rows}}, \tag{125}
$$
where $v^{\sharp}$ be the right-hand side of (124). In words, maximin strategy $q^{*}$ guarantees reward at least $v^{\sharp}$ against any adversary. Now, since $v^{*}=v^{\sharp}$ by Eq. (124), we can conclude the following:
**Corollary 9.4**
*$M(p^{*},q^{*})=v^{*}$ , and the pair $(p^{*},q^{*})$ forms a Nash equilibrium, in the sense that*
With this corollary, Eq. (124) is a celebrated early result in mathematical game theory, known as the minimax theorem. Surprisingly, it admits a simple alternative proof based on the existence of sublinear-regret algorithms and the machinery developed earlier in this chapter.
* Proof of Eq. (124)*
The $â„$ direction is easy:
| | $\displaystyle M(p,q)$ | $\displaystyleâ„\min_{p^{\prime}â\Delta_{\mathtt{rows}}}M(p^{\prime},q)\qquadâ qâ\Delta_{\mathtt{cols}}$ | |
| --- | --- | --- | --- | The $â€$ direction is the difficult part. Let us consider a full-feedback version of the repeated game studied earlier. Let $\mathtt{ALG}$ be any algorithm with subliner expected regret, e.g., $\mathtt{Hedge}$ algorithm from Chapter 27, and let $\mathtt{ADV}$ be the best-response adversary. Define
$$
\displaystyle h(q):=\inf_{p\in\Delta_{\mathtt{rows}}}M(p,q)=\min_{\text{rows $i$}}\;M(i,q) \tag{127}
$$
for each distribution $qâ\Delta_{\mathtt{cols}}$ , similarly to how $f(p)$ is defined in (119). We need to prove that
$$
\displaystyle\min_{p\in\Delta_{\mathtt{rows}}}f(p)\leq\max_{q\in\Delta_{\mathtt{cols}}}h(q). \tag{128}
$$
Let us take care of some preliminaries. Let $\bar{\jmath}$ be the average play of $\mathtt{ADV}$ , as per Definition 9.2. Then:
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}[\mathtt{cost}(i)] \displaystyle=\textstyle\sum_{t=1}^{T}\operatornamewithlimits{\mathbb{E}}[\,M(i,j_{t})\,]=T\,\operatornamewithlimits{\mathbb{E}}[\,M(i,\bar{\jmath})\,]=T\,M(i,\,\operatornamewithlimits{\mathbb{E}}[\bar{\jmath}])\qquad\text{for each row $i$} \displaystyle\tfrac{1}{T}\,\operatornamewithlimits{\mathbb{E}}[\mathtt{cost}^{*}] \displaystyle\leq\tfrac{1}{T}\,\min_{\text{rows $i$}}\operatornamewithlimits{\mathbb{E}}[\mathtt{cost}(i)]=\min_{\text{rows $i$}}M(i,\,\operatornamewithlimits{\mathbb{E}}[\bar{\jmath}])=\min_{p\in\Delta_{\mathtt{rows}}}M(p,\,\operatornamewithlimits{\mathbb{E}}[\bar{\jmath}])=h(\operatornamewithlimits{\mathbb{E}}[\bar{\jmath}]). \tag{129}
$$ The crux of the argument is as follows:
$$
\displaystyle\min_{p\in\Delta_{\mathtt{rows}}}f(p) \displaystyle\leq f(\,\operatornamewithlimits{\mathbb{E}}[\bar{\imath}]\,) \displaystyle\leq\tfrac{1}{T}\,\operatornamewithlimits{\mathbb{E}}[\mathtt{cost}(\mathtt{ALG})] \displaystyle=\tfrac{1}{T}\,\operatornamewithlimits{\mathbb{E}}[\mathtt{cost}^{*}]+\tfrac{\operatornamewithlimits{\mathbb{E}}[R(T)]}{T} \displaystyle\leq h(\operatornamewithlimits{\mathbb{E}}[\bar{\jmath}])+\tfrac{\operatornamewithlimits{\mathbb{E}}[R(T)]}{T} \displaystyle\leq\max_{q\in\Delta_{\mathtt{cols}}}h(q)+\tfrac{\operatornamewithlimits{\mathbb{E}}[R(T)]}{T}. \tag{123}
$$
Now, taking $Tââ$ implies Eq. (128) because $\operatornamewithlimits{\mathbb{E}}[R(T)]/Tâ 0$ , completing the proof. â
51 Regret-minimizing adversary
The most interesting version of our game is when the adversary itself is a regret-minimizing algorithm (possibly in a different feedback model). More formally, we posit that after each round $t$ the adversary observes its reward $M(i_{t},j_{t})$ and auxiliary feedback $\mathcal{F}^{\prime}_{t}=\mathcal{F}^{\prime}(t,i_{t},j_{t},M)$ , where $\mathcal{F}^{\prime}$ is some fixed feedback model. We consider the regret of $\mathtt{ADV}$ in this feedback model, denote it $R^{\prime}(T)$ . We use the minimax theorem to prove that $(\bar{\imath},\bar{\jmath})$ , the average play of $\mathtt{ALG}$ and $\mathtt{ADV}$ , approximates the Nash equilibrium $(p^{*},q^{*})$ .
First, let us express $\mathtt{cost}^{*}$ in terms of the function $h(·)$ from Eq. (127):
$$
\displaystyle\mathtt{cost}(i) \displaystyle=\textstyle\sum_{t=1}^{T}M(i,j_{t})=T\,M(i,\bar{\jmath})\qquad\text{for each row $i$} \displaystyle\tfrac{1}{T}\,\mathtt{cost}^{*} \displaystyle=\min_{\text{rows $i$}}M(i,\,\bar{\jmath})=h(\bar{\jmath}). \tag{130}
$$
Let us analyze $\mathtt{ALG}$ âs costs:
$$
\displaystyle\tfrac{1}{T}\,\mathtt{cost}(\mathtt{ALG})-\tfrac{R(T)}{T} \displaystyle=\tfrac{1}{T}\,\mathtt{cost}^{*} \displaystyle=h(\bar{\jmath}) \displaystyle\leq h(q^{*})=v^{\sharp} \displaystyle=v^{*} \tag{130}
$$
Similarly, analyze the rewards of $\mathtt{ADV}$ . Let $\mathtt{rew}(j)=\sum_{t=1}^{T}M(i_{t},j)$ be the total reward collected by the adversary for always choosing column $j$ , and let
$$
\mathtt{rew}^{*}:=\max_{\text{columns $j$}}\mathtt{rew}(j)
$$
be the reward of the âbest observed columnâ. Letâs take care of some formalities:
$$
\displaystyle\mathtt{rew}(j) \displaystyle=\textstyle\sum_{t=1}^{T}M(i_{t},j)=T\,M(\bar{\imath},\,j)\qquad\text{for each column $j$} \displaystyle\tfrac{1}{T}\,\mathtt{rew}^{*} \displaystyle=\max_{\text{columns $j$}}M(\bar{\imath},\,j)=\max_{q\in\Delta_{\mathtt{cols}}}M(\bar{\imath},\,q)=f(\bar{\imath}). \tag{132}
$$
Now, let us use the regret of $\mathtt{ADV}$ :
$$
\displaystyle\tfrac{1}{T}\,\mathtt{cost}(\mathtt{ALG})+\tfrac{R^{\prime}(T)}{T} \displaystyle=\tfrac{1}{T}\,\mathtt{rew}(\mathtt{ADV})+\tfrac{R^{\prime}(T)}{T} \displaystyle=\tfrac{1}{T}\,\mathtt{rew}^{*} \displaystyle=f(\bar{\imath}) \displaystyle\geq f(p^{*})=v^{*} \tag{132}
$$
Putting together (131) and (133), we obtain
$$
v^{*}-\tfrac{R^{\prime}(T)}{T}\leq f(\bar{\imath})-\tfrac{R^{\prime}(T)}{T}\leq\tfrac{1}{T}\,\mathtt{cost}(\mathtt{ALG})\leq h(\bar{\jmath})+\tfrac{R(T)}{T}\leq v^{*}+\tfrac{R(T)}{T}.
$$
Thus, we have the following theorem:
**Theorem 9.5**
*Let $R^{\prime}(T)$ be the regret of $\mathtt{ADV}$ . Then the average costs/rewards converge, in the sense that
| | $\displaystyle\tfrac{1}{T}\,\mathtt{cost}(\mathtt{ALG})=\tfrac{1}{T}\,\mathtt{rew}(\mathtt{ADV})â\left[v^{*}-\tfrac{R^{\prime}(T)}{T},\,v^{*}+\tfrac{R(T)}{T}\right].$ | |
| --- | --- | --- |
Moreover, the average play $(\bar{\imath},\bar{\jmath})$ forms an $\epsilon_{T}$ -approximate Nash equilibrium, with $\epsilon_{T}:=\tfrac{R(T)+R^{\prime}(T)}{T}$ :
| | $\displaystyle M(\bar{\imath},\,q)†v^{*}+\epsilon_{T}$ | $\displaystyle\qquadâ qâ\Delta_{\mathtt{cols}},$ | |
| --- | --- | --- | --- |*
The guarantees in Theorem 9.5 are strongest if $\mathtt{ALG}$ and $\mathtt{ADV}$ admit high-probability regret bounds, i.e., if
with probability at least $1-\gamma$ , for some functions $\tilde{R}(t)$ and $\tilde{R}^{\prime}(t)$ . Then the guarantees in Theorem 9.5 hold, with $R(T)$ and $R^{\prime}(T)$ replaced with, resp., $\tilde{R}(T)$ and $\tilde{R}^{\prime}(T)$ , whenever (134) holds. In particular, algorithm $\mathtt{Hedge}$ and a version of algorithm $\mathtt{Exp3}$ achieve high-probability regret bounds, resp., for full feedback with $R(T)=O(\sqrt{T\log K})$ , for bandit feedback with $R(T)=O(\sqrt{TK\log K})$ , where $K$ is the number of actions (Freund and Schapire, 1997; Auer et al., 2002b).
Further, we recover similar but weaker guarantees even if we only have a bound on expected regret:
**Corollary 9.6**
*$\tfrac{1}{T}\,\operatornamewithlimits{\mathbb{E}}[\mathtt{cost}(\mathtt{ALG})]=\tfrac{1}{T}\,\operatornamewithlimits{\mathbb{E}}[\mathtt{rew}(\mathtt{ADV})]â\left[v^{*}-\tfrac{\operatornamewithlimits{\mathbb{E}}[R^{\prime}(T)]}{T},\,v^{*}+\tfrac{\operatornamewithlimits{\mathbb{E}}[R(T)]}{T}\right].$ Moreover, the expected average play $(\operatornamewithlimits{\mathbb{E}}[\bar{\imath}],\,\operatornamewithlimits{\mathbb{E}}[\bar{\jmath}])$ forms an $\operatornamewithlimits{\mathbb{E}}[\epsilon_{T}]$ -approximate Nash equilibrium.*
This is because $\operatornamewithlimits{\mathbb{E}}[\,M(\bar{\imath},\,q)\,]=M(\operatornamewithlimits{\mathbb{E}}[\bar{\imath}],q)$ by linearity, and similarly for $\bar{\jmath}$ .
**Remark 9.7**
*Convergence of $\mathtt{cost}(\mathtt{ALG})$ to the corresponding equilibrium cost $v^{*}$ is characterized by the convergence rate $\tfrac{|\mathtt{cost}(\mathtt{ALG})-v^{*}|}{T}$ , as a function of $T$ . Plugging in generic $\tilde{O}(\sqrt{T})$ regret bounds into Theorem 9.5 yields convergence rate $\tilde{O}\left(\tfrac{1}{\sqrt{T}}\right)$ .*
52 Beyond zero-sum games: coarse correlated equilibrium
What can we prove if the game is not zero-sum? While we would like to prove convergence to a Nash Equilibrium, like in Theorem 9.5, this does not hold in general. However, one can prove a weaker notion of convergence, as we explain below. Consider distributions over row-column pairs, let $\Delta_{\mathtt{pairs}}$ be the set of all such distributions. We are interested in the average distribution defined as follows:
$$
\displaystyle\bar{\sigma}:=(\sigma_{1}+\ldots+\sigma_{T})/T\in\Delta_{\mathtt{pairs}},\qquad\text{where }\sigma_{t}:=p_{t}\times q_{t}\in\Delta_{\mathtt{pairs}} \tag{135}
$$
We argue that $\bar{\sigma}$ is, in some sense, an approximate equilibrium.
Imagine there is a âcoordinatorâ who takes some distribution $\sigmaâ\Delta_{\mathtt{pairs}}$ , draws a pair $(i,j)$ from this distribution, and recommends row $i$ to $\mathtt{ALG}$ and column $j$ to $\mathtt{ADV}$ . Suppose each player has only two choices: either âcommitâ to following the recommendation before it is revealed, or âdeviateâ and not look at the recommendation. The equilibrium notion that we are interested here is that each player wants to âcommitâ given that the other does.
Formally, assume that $\mathtt{ADV}$ âcommitsâ. The expected costs for $\mathtt{ALG}$ are
| | $\displaystyle U_{\sigma}:=\operatornamewithlimits{\mathbb{E}}_{(i,j)\sim\sigma}M(i,j)$ | $\displaystyle\qquad\text{if $\mathtt{ALG}$ ``commits"},$ | |
| --- | --- | --- | --- |
Distribution $\sigmaâ\Delta_{\mathtt{pairs}}$ is a coarse correlated equilibrium (CCE) if $U_{\sigma}â„ U_{\sigma}(i_{0})$ for each row $i_{0}$ , and a similar property holds for $\mathtt{ADV}$ .
We are interested in the approximate version of this property: $\sigmaâ\Delta_{\mathtt{pairs}}$ is an $\epsilon$ -approximate CCE if
$$
\displaystyle U_{\sigma}\geq U_{\sigma}(i_{0})-\epsilon\qquad\text{for each row $i_{0}$} \tag{136}
$$
and similarly for $\mathtt{ADV}$ . It is easy to see that distribution $\bar{\sigma}$ achieves this with $\epsilon=\tfrac{\operatornamewithlimits{\mathbb{E}}[R(T)]}{T}$ . Indeed,
| | $\displaystyle U_{\bar{\sigma}}$ | $\displaystyle:=\operatornamewithlimits{\mathbb{E}}_{(i,j)\sim\bar{\sigma}}\left[\,M(i,j)\,\right]=\tfrac{1}{T}\,\sum_{t=1}^{T}\operatornamewithlimits{\mathbb{E}}_{(i,j)\sim\sigma_{t}}\left[\,M(i,j)\,\right]=\tfrac{1}{T}\,\operatornamewithlimits{\mathbb{E}}[\mathtt{cost}(\mathtt{ALG})]$ | |
| --- | --- | --- | --- |
Hence, $\bar{\sigma}$ satisfies Eq. (136) with $\epsilon=\tfrac{\operatornamewithlimits{\mathbb{E}}[R(T)]}{T}$ by definition of regret. Thus:
**Theorem 9.8**
*Distribution $\bar{\sigma}$ defined in (135) forms an $\epsilon_{T}$ -approximate CCE, where $\epsilon_{T}=\tfrac{\operatornamewithlimits{\mathbb{E}}[R(T)]}{T}$ .*
53 Literature review and discussion
The results in this chapter stem from extensive literature on learning in repeated games, an important subject in theoretical economics. A deeper discussion of this subject from the online machine learning perspective can be found in Cesa-Bianchi and Lugosi (2006, Chapter 7) and the bibliographic notes therein. Empirical evidence that regret-minimization is a plausible model of self-interested behavior can be found in recent studies (Nekipelov et al., 2015; Nisan and Noti, 2017).
53.1 Zero-sum games
Some of the early work concerns fictitious play: two-player zero-sum games where each player best-responds to the empirical play of the opponent (i.e., the historical frequency distribution over the arms). Introduced in Brown (1949), fictitious play was proved to converge at the rate $O(t^{-1/n})$ for $nĂ n$ game matrices (Robinson, 1951). This convergence rate is the best possible (Daskalakis and Pan, 2014).
The repeated game between two regret-minimizing algorithms serves as a subroutine for a variety of algorithmic problems. This approach can be traced to Freund and Schapire (1996, 1999). It has been used as a unifying algorithmic framework for several problems: boosting Freund and Schapire (1996), linear programs Arora et al. (2012), maximum flow Christiano et al. (2011), and convex optimization Abernethy and Wang (2017); Wang and Abernethy (2018). In conjunction with a specific way to define the game matrix, this approach can solve a variety of constrained optimization problems, with application domains ranging from differential privacy to algorithmic fairness to learning from revealed preferences (Rogers et al., 2015; Hsu et al., 2016; Roth et al., 2016; Kearns et al., 2018; Agarwal et al., 2017a; Roth et al., 2017). In Chapter 10, this approach is used to solve bandits with global constraints.
Refinements. Our analysis can be refined for algorithm $\mathtt{Hedge}$ and/or the best-response adversary:
- The best-response adversary can be seen as a regret-minimizing algorithm which satisfies Theorem 9.5 with $\operatornamewithlimits{\mathbb{E}}[R^{\prime}(T)]†0$ ; see Exercise 9.2.
- The $\mathtt{Hedge}$ vs. $\mathtt{Hedge}$ game satisfies the approximate Nash property from Theorem 9.5 with probability $1$ , albeit in a modified feedback model; see Exercise 9.3 (b).
- The $\mathtt{Hedge}$ vs. Best Response game also satisfies the approximate Nash property with probability $1$ ; see Exercise 9.3 (c).
The last two results can be used for computing an approximate Nash equilibrium for a known matrix $M$ .
The results in this chapter admit multiple extensions, some of which are discussed below.
- Theorem 9.5 can be extended to stochastic games, where in each round $t$ , the game matrix $M_{t}$ is drawn independently from some fixed distribution over game matrices (see Exercise 9.4).
- One can use algorithms with better regret bounds if the game matrix $M$ allows it. For example, $\mathtt{ALG}$ can be an algorithm for Lipschitz bandits if all functions $M(·,j)$ satisfy a Lipschitz condition. That is, if $|M(i,j)-M(i^{\prime},j)|†D(i,i^{\prime})$ for all rows $i,i^{\prime}$ and all columns $j$ , for some known metric $D$ on rows.
- Theorem 9.5 and the minimax theorem can be extended to infinite action sets, as long as $\mathtt{ALG}$ and $\mathtt{ADV}$ admit $o(T)$ expected regret for the repeated game with a given game matrix; see Exercise 9.5 for a precise formulation.
Faster convergence. Rakhlin and Sridharan (2013b); Daskalakis et al. (2015) obtain $\tilde{O}(\frac{1}{t})$ convergence rates for repeated zero-sum games with full feedback. (This is a big improvement over the $\tilde{O}(t^{-1/2})$ convergence results in this chapter, see Remark 9.7.) Wei and Luo (2018) obtains $\tilde{O}(t^{-3/4})$ convergence rate for repeated zero-sum games with bandit feedback. These results are for specific classes of algorithms, and rely on improved analyses of the repeated game.
Last-iterate convergence. While all convergence results in this chapter are only in terms of the average play, it is very tempting to ask whether the actual play $(i_{t},j_{t})$ converges, too. In the literature, such results are called last-iterate convergence and topological convergence.
With $\mathtt{Hedge}$ and some other standard algorithms, the results are mixed. On the one hand, strong negative results are known, with a detailed investigation of the non-converging behavior (Bailey and Piliouras, 2018; Mertikopoulos et al., 2018; Cheung and Piliouras, 2019). On the other hand, $\mathtt{Hedge}$ admits a strong positive result for congestion games, a well-studied family of games where a playerâs utility for a given action depends only on the number of other players which choose an âoverlappingâ action. In fact, there is a family of regret-minimizing algorithms which generalize $\mathtt{Hedge}$ such that we have last-iterate convergence in repeated congestion games if each player uses some algorithm from this family (Kleinberg et al., 2009b).
A recent flurry of activity, starting from Daskalakis et al. (2018), derives general results on last-iterate convergence (see Daskalakis and Panageas, 2019; Golowich et al., 2020; Wei et al., 2021, and references therein). These results apply to the main setting in this chapter: arbitrary repeated zero-sum games with two players and finitely many actions, and extend beyond that under various assumptions. All these results require full feedback, and hinge upon two specific, non-standard regret-minimizing algorithms.
53.2 Beyond zero-sum games
Correlated equilibria. Coarse correlated equilibrium, introduced in (Moulin and Vial, 1978), is a classic notion in theoretical economics. The simple argument in Section 52 appears to be folklore.
A closely related notion called correlated equilibrium (Aumann, 1974), posits that
$$
\operatornamewithlimits{\mathbb{E}}_{(i,j)\sim\sigma}\left[\;M(i,j)-M(i_{0},j)\mid i\;\right]\geq 0\qquad\text{for each row $i_{0}$},
$$
and similarly for $\mathtt{ADV}$ . This is a stronger notion, in the sense that any correlated equilibrium is a coarse correlated equilibrium, but not vice versa. One obtains an approximate correlated equilibria, in a sense similar to Theorem 9.8, if $\mathtt{ALG}$ and $\mathtt{ADV}$ have sublinear internal regret (Hart and Mas-Colell, 2000, also see Section 35 in this book). Both results easily extend to games with multiple players. We specialized the discussion to the case of two players for ease of presentation only.
Smooth games is a wide class of multi-player games which admit strong guarantees about the self-interested behavior being ânot too badâ (Roughgarden, 2009; Syrgkanis and Tardos, 2013; Lykouris et al., 2016). More formally, the price of anarchy â the ratio between the social welfare (agentsâ total reward) in the best centrally coordinated solution and the worst Nash equilibrium â can be usefully upper-bounded in terms of the game parameters. More background can be found in the textbook Roughgarden (2016), as well as in many recent classes on algorithmic game theory. Repeated smooth games admit strong convergence guarantees: social welfare of average play converges over time, for arbitrary regret-minimizing algorithms (Blum et al., 2008; Roughgarden, 2009). Moreover, one can achieve faster convergence, at the rate $\tilde{O}(\tfrac{1}{t})$ , under some assumptions on the algorithmsâ structure (Syrgkanis et al., 2015; Foster et al., 2016a).
Cognitive radios. An application to cognitive radios has generated much interest, starting from Lai et al. (2008); Liu and Zhao (2010); Anandkumar et al. (2011), and continuing to, e.g., Avner and Mannor (2014); Rosenski et al. (2016); Boursier and Perchet (2019); Bubeck et al. (2020). In this application, multiple radios transmit simultaneously in a shared medium. Each radio can switch among different available channels. Whenever two radios transmit on the same channel, a collision occurs, and the transmission does not get through. Each radio chooses channels over time using a multi-armed bandit algorithm. The whole system can be modeled as a repeated game between bandit algorithms.
This line of work has focused on designing algorithms which work well in the repeated game, rather than studying the repeated game between arbitrary algorithms. Various assumptions are made regarding whether and to which extent communication among algorithms is allowed, the algorithms can be synchronized with one another, and collisions are detected. It is typically assumed that each radio transmits continuously.
54 Exercises and hints
**Exercise 9.1 (game-theory basics)**
*- Prove that a distribution $pâ\Delta_{\mathtt{rows}}$ satisfies Eq. (120) if and only if it is a minimax strategy.
Hint: $M(p^{*},q)†f(p^{*})$ if $p^{*}$ is a minimax strategy; $f(p)†v^{*}$ if $p$ satisfies (120).
- Prove that $pâ\Delta_{\mathtt{rows}}$ and $qâ\Delta_{\mathtt{cols}}$ form a Nash equilibrium if and only if $p$ is a minimax strategy and $q$ is a maximin strategy.*
**Exercise 9.2 (best-response adversary)**
*The best-response adversary, as defined in Eq. (122), can be seen as an algorithm in the setting of Chapter 51. (More formally, this algorithm knows $\mathtt{ALG}$ and the game matrix $M$ , and receives auxiliary feedback $\mathcal{F}_{t}=j_{t}$ .) Prove that its expected regret satisfies $\operatornamewithlimits{\mathbb{E}}[R^{\prime}(T)]†0$ . Take-away: Thus, Theorem 9.5 applies to the best-response adversary, with $\operatornamewithlimits{\mathbb{E}}[R^{\prime}(T)]†0$ .*
**Exercise 9.3 (Hedge vs. Hedge)**
*Suppose both $\mathtt{ALG}$ and $\mathtt{ADV}$ are implemented by algorithm $\mathtt{Hedge}$ . Assume that $M$ is a $KĂ K$ matrix with entries in $[0,1]$ , and the parameter in $\mathtt{Hedge}$ is $\epsilon=\sqrt{(\ln K)/(2T)}$ . - Consider the full-feedback model. Prove that the average play $(\bar{\imath},\bar{\jmath})$ forms a $\delta_{T}$ -approximate Nash equilibrium with high probability (e.g., with probability at least $1-T^{-2}$ ), where $\delta_{T}=O\left(\sqrt{\tfrac{\ln(KT)}{T}}\right)$ .
- Consider a modified feedback model: in each round $t$ , $\mathtt{ALG}$ is given costs $M(·,q_{t})$ , and $\mathtt{ADV}$ is given rewards $M(p_{t},·)$ , where $p_{t}â\Delta_{\mathtt{rows}}$ and $q_{t}â\Delta_{\mathtt{cols}}$ are the distributions chosen by $\mathtt{ALG}$ and $\mathtt{ADV}$ , respectively. Prove that the average play $(\bar{\imath},\bar{\jmath})$ forms a $\delta_{T}$ -approximate Nash equilibrium.
- Suppose $\mathtt{ADV}$ is the best-response adversary, as per Eq. (122), and $\mathtt{ALG}$ is $\mathtt{Hedge}$ with full feedback. Prove that $(\bar{\imath},\bar{\jmath})$ forms a $\delta_{T}$ -approximate Nash equilibrium. Hint: Follow the steps in the proof of Theorem 9.5, but use the probability-1 performance guarantee for $\mathtt{Hedge}$ (Eq. (84) on page 84) instead of the standard definition of regret (118). For part (a), define $\widetilde{\mathtt{cost}}(\mathtt{ALG}):=\sum_{tâ[T]}M(p_{t},j_{t})$ and $\widetilde{\mathtt{rew}}(\mathtt{ADV}):=\sum_{tâ[T]}M(i_{t},q_{t})$ , and use Eq. (84) to conclude that they are close to $\mathtt{cost}^{*}$ and $\mathtt{rew}^{*}$ , respectively. Apply Azuma-Hoeffding inequality to prove that both $\widetilde{\mathtt{cost}}(\mathtt{ALG})$ and $\widetilde{\mathtt{rew}}(\mathtt{ADV})$ are close to $\sum_{tâ[T]}M(p_{t},q_{t})$ . For part (b), define $\widetilde{\mathtt{cost}}(\mathtt{ALG}):=\widetilde{\mathtt{rew}}(\mathtt{ADV}):=\sum_{tâ[T]}M(p_{t},q_{t})$ , and use Eq. (84) to conclude that it is close to both $\mathtt{cost}^{*}$ and $\mathtt{rew}^{*}$ . For part (c), define $\widetilde{\mathtt{cost}}(\mathtt{ALG})=\widetilde{\mathtt{rew}}(\mathtt{ADV})$ and handle $\mathtt{Hedge}$ as in part (b). Modify (133), starting from $\widetilde{\mathtt{rew}}(\mathtt{ADV})$ , to handle the best-response adversary.*
**Exercise 9.4 (stochastic games)**
*Consider an extension to stochastic games: in each round $t$ , the game matrix $M_{t}$ is drawn independently from some fixed distribution over game matrices. Assume all matrices have the same dimensions (number of rows and columns). Suppose both $\mathtt{ALG}$ and $\mathtt{ADV}$ are regret-minimizing algorithms, as in Section 51, and let $R(T)$ and $R^{\prime}(T)$ be their respective regret. Prove that the average play $(\bar{\imath},\bar{\jmath})$ forms a $\delta_{T}$ -approximate Nash equilibrium for the expected game matrix $M=\operatornamewithlimits{\mathbb{E}}[M_{t}]$ , with
$$
\delta_{T}=\tfrac{R(T)+R^{\prime}(T)}{T}+\mathtt{err},\text{ where }\textstyle\mathtt{err}=\left|\sum_{t\in[T]}M_{t}(i_{t},j_{t})-M(i_{t},j_{i})\right|.
$$ Hint: The total cost/reward is now $\sum_{tâ[T]}M_{t}(i_{t},j_{t})$ . Transition from this to $\sum_{tâ[T]}M(i_{t},j_{t})$ using the error term $\mathtt{err}$ , and follow the steps in the proof of Theorem 9.5. Note: If all matrix entries are in the $[a,b]$ interval, then $\mathtt{err}â[0,b-a]$ , and by Azuma-Hoeffing inequality $\mathtt{err}<O(b-a)\sqrt{\log(T)/T}$ with probability at most $1-T^{-2}$ .*
**Exercise 9.5 (infinite action sets)**
*Consider an extension of the repeated game to infinite action sets. Formally, $\mathtt{ALG}$ and $\mathtt{ADV}$ have action sets $I$ , $J$ , resp., and the game matrix $M$ is a function $IĂ Jâ[0,1]$ . $I$ and $J$ can be arbitrary sets with well-defined probability measures such that each singleton set is measurable. Assume there exists a function $\tilde{R}(T)=o(T)$ such that expected regret of $\mathtt{ALG}$ is at most $\tilde{R}(T)$ for any $\mathtt{ADV}$ , and likewise expected regret of $\mathtt{ADV}$ is at most $\tilde{R}(T)$ for any $\mathtt{ALG}$ . - Prove an appropriate versions of the minimax theorem:
| | $\displaystyleâf_{pâ\Delta_{\mathtt{rows}}}\;\sup_{jâ J}\;ât M(p,j)\mathop{}\!\mathrm{d}p=\sup_{qâ\Delta_{\mathtt{cols}}}\;âf_{iâ I}\;ât M(i,q)\mathop{}\!\mathrm{d}q,$ | |
| --- | --- | --- |
where $\Delta_{\mathtt{rows}}$ and $\Delta_{\mathtt{cols}}$ are now the sets of all probability measures on $I$ and $J$ .
- Formulate and prove an appropriate version of Theorem 9.5. Hint: Follow the steps in Sections 50 and 51 with minor modifications. Distributions over rows and columns are replaced with probability measures over $I$ and $J$ . Maxima and minima over $I$ and $J$ are replaced with $\sup$ and $âf$ . Best response returns a distribution over $Y$ (rather than a particular column).*
Chapter 10 Bandits with Knapsacks
Bandits with Knapsacks ( $\mathtt{BwK}$ ) is a general framework for bandit problems with global constraints such as supply constraints in dynamic pricing. We define and motivate the framework, and solve it using the machinery from Chapter 9. We also describe two other algorithms for $\mathtt{BwK}$ , based on âsuccessive eliminationâ and âoptimism under uncertaintyâ paradigms from Chapter 1.
Prerequisites: Chapters 1, 5, 6, 9.
55 Definitions, examples, and discussion
Motivating example. We start with a motivating example: dynamic pricing with limited supply. The basic version of this problem is as follows. The algorithm is a seller, with a limited inventory of $B$ identical items for sale. There are $T$ rounds. In each round $t$ , the algorithm chooses a price $p_{t}â[0,1]$ and offers one item for sale at this price. A new customer arrives, having in mind some value $v_{t}$ for this item (known as private value). We posit that $v_{t}$ is drawn independently from some fixed but unknown distribution. The customer buys the item if and only if $v_{t}â„ p_{t}$ , and leaves. The algorithm stops after $T$ rounds or after there are no more items to sell, whichever comes first. The algorithmâs goal is to maximize revenue from the sales; there is no premium or rebate for the left-over items. Recall that the special case $B=T$ (i.e., unlimited supply of items) falls under âstochastic banditsâ, where arms corresponds to prices. However, with $B<T$ we have a âglobalâ constraint: a constraint that binds across all rounds and all actions.
More generally, the algorithm may have $n>1$ products in the inventory, with a limited supply of each. In each round $t$ , the algorithm chooses a price $p_{t,i}$ for each product $i$ , and offers one copy of each product for sale. A new customer arrives, with a vector of private values $v_{t}=(v_{t,1}\,,\ ...\ ,v_{t,n})$ , and buys each product $i$ such that $v_{t,i}â„ p_{t,i}$ . The vector $v_{t}$ is drawn independently from some distribution. If the values are independent across products, i.e., $v_{t,1}\,,\ ...\ ,v_{t,n}$ are mutually independent random variables, then the problem can be decoupled into $n$ separate per-product problems. However, in general the values may be correlated. We interpret this scenario as a stochastic bandits problem, where actions correspond to price vectors $p_{t}=(p_{t,1}\,,\ ...\ ,p_{t,n})$ , and we have a separate âglobal constraintâ on each product.
General framework. We introduce a general framework for bandit problems with global constraints, called âbandits with knapsacksâ, which subsumes dynamic pricing and many other examples. In this framework, there are several constrained resources being consumed by the algorithm, such as the inventory of products in the dynamic pricing problem. One of these resources is time: each arm consumes one unit of the âtime resourceâ in each round, and its budget is the time horizon $T$ . The algorithm stops when the total consumption of some resource $i$ exceeds its respective budget $B_{i}$ .
Problem protocol: Bandits with Knapsacks ( $\mathtt{BwK}$ )
Parameters: $K$ arms, $d$ resources with respective budgets $B_{1}\,,\ ...\ ,B_{d}â[0,T]$ . In each round $t=1,2,3\,...$ :
- Algorithm chooses an arm $a_{t}â[K]$ .
- Outcome vector $\vec{o}_{t}=(r_{t};c_{t,1}\,,\ ...\ ,c_{t,d})â[0,1]^{d+1}$ is observed, where $r_{t}$ is the algorithmâs reward, and $c_{t,i}$ is consumption of each resource $i$ .
Algorithm stops when the total consumption of some resource $i$ exceeds its budget $B_{i}$ .
In each round, an algorithm chooses an arm, receives a reward, and also consumes some amount of each resource. Thus, the outcome of choosing an arm is now a $(d+1)$ -dimensional vector rather than a scalar. As a technical assumption, the reward and consumption of each resource in each round lie in $[0,1]$ . We posit the âIID assumptionâ, which now states that for each arm $a$ the outcome vector is sampled independently from a fixed distribution over outcome vectors. Formally, an instance of $\mathtt{BwK}$ is specified by parameters $T,K,d$ , budgets $B_{1}\,,\ ...\ ,B_{d}$ , and a mapping from arms to distributions over outcome vectors. The algorithmâs goal is to maximize its adjusted total reward: the total reward over all rounds but the very last one.
The name âbandits with knapsacksâ comes from an analogy with the well-known knapsack problem in algorithms. In that problem, one has a knapsack of limited size, and multiple items each of which has a value and takes a space in the knapsack. The goal is to assemble the knapsack: choose a subset of items that fits in the knapsacks so as to maximize the total value of these items. Similarly, in dynamic pricing each action $p_{t}$ has âvalueâ (the revenue from this action) and âsize in the knapsackâ (namely, the number of items sold). However, in $\mathtt{BwK}$ the âvalueâ and âsizeâ of a given action are not known in advance.
**Remark 10.1**
*The special case $B_{1}=...=B_{d}=T$ is just âstochastic banditsâ, as in Chapter 1.*
**Remark 10.2**
*An algorithm can continue while there are sufficient resources to do so, even if it almost runs out of some resources. Then the algorithm should only choose âsafeâ arms if at all possible, where an arm is called âsafeâ if playing this arm in the current round cannot possibly cause the algorithm to stop.*
Discussion. Compared to stochastic bandits, $\mathtt{BwK}$ is more challenging in several ways. First, resource consumption during exploration may limit the algorithmâs ability to exploit in the future rounds. A stark consequence is that Explore-first algorithm fails if the budgets are too small, see Exercise 10.1 (a). Second, per-round expected reward is no longer the right objective. An arm with high per-round expected reward may be undesirable because of high resource consumption. Instead, one needs to think about the total expected reward over the entire time horizon. Finally, learning the best arm is no longer the right objective! Instead, one is interested in the best fixed distribution over arms. This is because a fixed distribution over arms can perform much better than the best fixed arm. All three challenges arise even when $d=2$ (one resource other than time), $K=2$ arms, and $B>\Omega(T)$ .
To illustrate the distinction between the best fixed distribution and the best fixed arm, consider the following example. There are two arms $aâ\{1,2\}$ and two resources $iâ\{1,2\}$ other than time. In each round, each arm $a$ yields reward $1$ , and consumes ${\bf 1}_{\left\{\,a=i\,\right\}}$ units of each resource $i$ . For intuition, plot resource consumption on a plane, so that there is a âhorizontalâ am which consumes only the âhorizontalâ resource, and a âverticalâ arm which consumes only the âverticalâ resource, see Figure 5. Both resources have budget $B$ , and time horizon is $T=2B$ . Then always playing the same arm gives the total reward of $B$ , whereas alternating the two arms gives the total reward of $2B$ . Choosing an arm uniformly (and independently) in each round yields the same expected total reward of $2B$ , up to a low-order error term.
<details>
<summary>figures/ch-BwK-example.png Details</summary>
### Visual Description
# Technical Document Extraction: Resource Allocation Diagram
## 1. Document Overview
This image is a technical diagram representing a path or trajectory within a 2D coordinate system, likely illustrating a resource allocation strategy or a multi-armed bandit problem. It utilizes a Cartesian-style plot with directional arrows to show a sequence of movements.
## 2. Component Isolation
### A. Coordinate System (Axes)
* **Horizontal Axis (X-axis):** Represented by a solid orange line with an arrowhead pointing right.
* **Label:** "resource 1" (located at the bottom right).
* **Origin Label:** "arm 1" (located at the bottom left, near the intersection).
* **Vertical Axis (Y-axis):** Represented by a solid orange line with an arrowhead pointing upward.
* **Label:** "resource 2" (located at the top left).
* **Origin Label:** "arm 2" (located on the left, slightly above the origin).
### B. Boundary Markers
* **Dashed Lines:** A black dashed line extends horizontally from the top of the Y-axis and vertically from the end of the X-axis, forming a rectangular boundary for the "resource space."
## 3. Data Series and Path Analysis
The diagram features a path composed of several discrete segments (arrows). There are two distinct colors/styles used for the initial movements at the origin, followed by a unified path.
### Initial Vectors (Origin)
1. **Vertical Black Arrow:** A thick black arrow starts at the origin and points upward along the Y-axis toward the "arm 2" label.
2. **Horizontal Black Arrow:** A thick black arrow starts at the origin and points right along the X-axis toward the "arm 1" label.
### Main Trajectory (Tan/Gold Arrows)
The primary data series is a "staircase" or "step" trend moving from the origin toward the top-right boundary. The trend is **monotonically increasing** in both dimensions.
**Step-by-Step Path Description:**
1. **Segment 1 (Horizontal):** Starts at the origin, moves right along the X-axis.
2. **Segment 2 (Vertical):** Moves upward.
3. **Segment 3 (Horizontal):** Moves right.
4. **Segment 4 (Vertical):** Moves upward.
5. **Segment 5 (Horizontal):** Moves right.
6. **Segment 6 (Vertical):** Moves upward, terminating at the intersection of the dashed boundary lines.
## 4. Textual Information Extraction
| Label | Location | Context |
| :--- | :--- | :--- |
| **arm 1** | Bottom Left | X-axis origin/starting point |
| **arm 2** | Middle Left | Y-axis origin/starting point |
| **resource 1** | Bottom Right | X-axis variable/limit |
| **resource 2** | Top Left | Y-axis variable/limit |
## 5. Technical Interpretation
The diagram illustrates a sequential decision-making process where two "arms" (likely representing options or agents) consume two types of "resources."
* The **black arrows** represent the individual directions associated with each arm.
* The **tan staircase path** represents a combined or alternating allocation strategy that eventually reaches the maximum capacity defined by the dashed boundary.
* The path suggests a discrete, incremental progression rather than a continuous linear diagonal, indicating that resources are likely allocated in specific "steps" or "rounds."
</details>
Figure 5: Example: alternating arm is twice as good as a fixed arm
Benchmarks. We compare a $\mathtt{BwK}$ algorithm against an all-knowing benchmark: informally, the best thing one could do if one knew the problem instance. Without resources, âthe best thing one could doâ is always play the best arm. For $\mathtt{BwK}$ , there are three reasonable benchmarks one could consider: best arm, best distribution over arms, and best algorithm. These benchmarks are defined in a uniform way:
$$
\displaystyle\mathtt{OPT}_{\mathcal{A}}(\mathcal{I})=\sup_{\text{algorithms}\;\mathtt{ALG}\in\mathcal{A}}\operatornamewithlimits{\mathbb{E}}\left[\,\mathtt{REW}(\mathtt{ALG}\mid\mathcal{I})\,\right], \tag{137}
$$
where $\mathcal{I}$ is a problem instance, $\mathtt{REW}(\mathtt{ALG}\mid\mathcal{I})$ is the adjusted total reward of algorithm $\mathtt{ALG}$ on this problem instance, and $\mathcal{A}$ is a class of algorithms. Thus:
- if $\mathcal{A}$ is the class of all $\mathtt{BwK}$ algorithms, we obtain the best algorithm benchmark, denoted $\mathtt{OPT}$ ; this is the main benchmark in this chapter.
- if algorithms in $\mathcal{A}$ are fixed distributions over arms, i.e., they draw an arm independently from the same distribution in each round, we obtain the fixed-distribution benchmark, denoted $\mathtt{OPT_{FD}}$ .
- if algorithms in $\mathcal{A}$ are fixed arms, i.e., if they choose the same arm in each round, we obtain the fixed-arm benchmark, denoted $\mathtt{OPT_{FA}}$ .
Obviously, $\mathtt{OPT_{FA}}â€\mathtt{OPT_{FD}}â€\mathtt{OPT}$ . Generalizing the example above, $\mathtt{OPT_{FD}}$ could be up to $d$ times larger than $\mathtt{OPT_{FA}}$ , see Exercise 10.2. In fact, similar examples exist for the main motivating applications of $\mathtt{BwK}$ (Badanidiyuru et al., 2013, 2018). The difference between $\mathtt{OPT}$ and $\mathtt{OPT_{FD}}$ is not essential in this chapterâs technical presentation (but it is for some of the other results spelled out in the literature review).
56 Examples
We illustrate the generality of $\mathtt{BwK}$ with several examples. In all these examples, âtime resourceâ is the last component of the outcome vector.
- Dynamic pricing. Dynamic pricing with a single product is a special case of $\mathtt{BwK}$ with two resources: time (i.e., the number of customers) and supply of the product. Actions correspond to chosen prices $p$ . If the price is accepted, reward is $p$ and resource consumption is $1$ . Thus, the outcome vector is
$$
\displaystyle\vec{o}_{t}=\begin{cases}(p,1,1)&\text{if price $p$ is accepted}\\
(0,0,1)&\text{otherwise}.\end{cases} \tag{138}
$$
- Dynamic pricing for hiring, a.k.a. dynamic procurement. A contractor on a crowdsourcing market has a large number of similar tasks, and a fixed amount of money, and wants to hire some workers to perform these tasks. In each round $t$ , a worker shows up, the algorithm chooses a price $p_{t}$ , and offers a contract for one task at this price. The worker has a value $v_{t}$ in mind, and accepts the offer (and performs the task) if and only if $p_{t}â„ v_{t}$ . The goal is to maximize the number of completed tasks.
This problem as a special case of $\mathtt{BwK}$ with two resources: time (i.e., the number of workers) and contractorâs budget. Actions correspond to prices $p$ ; if the offer is accepted, the reward is $1$ and the resource consumption is $p$ . So, the outcome vector is
$$
\displaystyle\vec{o}_{t}=\begin{cases}(1,p,1)&\text{if price $p$ is accepted}\\
(0,0,1)&\text{otherwise}.\end{cases} \tag{139}
$$
- Pay-per-click ad allocation. There is an advertising platform with pay-per-click ads (advertisers pay only when their ad is clicked). For any ad $a$ there is a known per-click reward $r_{a}$ : the amount an advertiser would pay to the platform for each click on this ad. If shown, each ad $a$ is clicked with some fixed but unknown probability $q_{a}$ . Each advertiser has a limited budget of money that he is allowed to spend on her ads. In each round, a user shows up, and the algorithm chooses an ad. The algorithmâs goal is to maximize the total reward.
This problem is a special case of $\mathtt{BwK}$ with one resource for each advertiser (her budget) and the âtimeâ resource (i.e., the number of users). Actions correspond to ads. Each ad $a$ generates reward $r_{a}$ if clicked, in which case the corresponding advertiser spends $r_{a}$ from her budget. In particular, for the special case of one advertiser the outcome vector is:
$$
\displaystyle\vec{o}_{t}=\begin{cases}(r_{a},r_{a},1)&\text{if ad $a$ is clicked}\\
(0,0,1)&\text{otherwise}.\end{cases} \tag{140}
$$
- Repeated auctions. An auction platform such as eBay runs many instances of the same auction to sell $B$ copies of the same product. At each round, a new set of bidders arrives, and the platform runs a new auction to sell an item. The auction s parameterized by some parameter $\theta$ : e.g., the second price auction with the reserve price $\theta$ . In each round $t$ , the algorithm chooses a value $\theta=\theta_{t}$ for this parameter, and announces it to the bidders. Each bidder is characterized by the value for the item being sold; in each round, the tuple of biddersâ values is drawn from some fixed but unknown distribution over such tuples. Algorithmâs goal is to maximize the total profit from sales.
This is a special case of $\mathtt{BwK}$ with two resources: time (i.e., the number of auctions) and the limited supply of the product. Arms correspond to feasible values of parameter $\theta$ . The outcome vector is:
| | $\displaystyle\vec{o}_{t}=\begin{cases}(p_{t},1,1)&\text{if an item is sold at price $p_{t}$}\\
(0,0,1)&\text{otherwise}.\end{cases}$ | |
| --- | --- | --- |
The price $p_{t}$ is determined by the parameter $\theta$ and the bids in this round.
- Dynamic bidding on a budget. Letâs look at a repeated auction from a bidderâs perspective. It may be a complicated auction that the bidder does not fully understand. In particular, the bidder often not know the best bidding strategy, but may hope to learn it over time. Accordingly, we consider the following setting. In each round $t$ , one item is offered for sale. An algorithm chooses a bid $b_{t}$ and observes whether it receives an item and at which price. The outcome (whether we win an item and at which price) is drawn from a fixed but unknown distribution. The algorithm has a limited budget and aims to maximize the number of items bought.
This is a special case of $\mathtt{BwK}$ with two resources: time (i.e., the number of auctions) and the bidderâs budget. The outcome vector is
| | $\displaystyle\vec{o}_{t}=\begin{cases}(1,p_{t},1)&\text{if the bidder wins the item and pays $p_{t}$}\\
(0,0,1)&\text{otherwise}.\end{cases}$ | |
| --- | --- | --- |
The payment $p_{t}$ is determined by the chosen bid $b_{t}$ , other bids, and the rules of the auction.
57 LagrangeBwK: a game-theoretic algorithm for $\mathtt{BwK}$
We present an algorithm for $\mathtt{BwK}$ , called $\mathtt{LagrangeBwK}$ , which builds on the zero-sum games framework developed in Chapter 9. On a high level, our approach consists of four steps:
Linear relaxation
We consider a relaxation of $\mathtt{BwK}$ in which a fixed distribution $D$ over arms is used in all rounds, and outcomes are equal to their expected values. This relaxation can be expressed as a linear program for optimizing $D$ , whose per-round value is denoted $\mathtt{OPT}_{\mathtt{LP}}$ We prove that $\mathtt{OPT}_{\mathtt{LP}}â„\mathtt{OPT}/T$ . Lagrange game
We consider the Lagrange function $\mathcal{L}$ associated with this linear program. We focus on the Lagrange game: a zero-sum game, where one player chooses an arm $a$ , the other player chooses a resource $i$ , and the payoff is $\mathcal{L}(a,i)$ . We prove that the value of this game is $\mathtt{OPT}_{\mathtt{LP}}$ . Repeated Lagrange game
We consider a repeated version of this game. In each round $t$ , the payoffs are given by Lagrange function $\mathcal{L}_{t}$ , which is defined by this roundâs outcomes in a similar manner as $\mathcal{L}$ is defined by the expected outcomes. Each player is controlled by a regret-minimizing algorithm. The analysis from Chapter 9 connects the average play in this game with its Nash equilibrium. Reward at the stopping time
The final step argues that the reward at the stopping time is large compared to the ârelevantâ value of the Lagrange function (which in turn is large enough because of the Nash property). Interestingly, this step only relies on the definition of $\mathcal{L}$ , and holds for any algorithm.
Conceptually, these steps connect $\mathtt{BwK}$ to the linear program, to the Lagrange game, to the repeated game, and back to $\mathtt{BwK}$ , see Figure 6. We flesh out the details in what follows.
<details>
<summary>x3.png Details</summary>
### Visual Description
# Technical Document Extraction: BwK Theoretical Framework Diagram
## 1. Image Overview
This image is a technical flow diagram illustrating the theoretical connections and reductions between "Bandits with Knapsacks" (BwK) and various mathematical frameworks, including Linear Programming and Game Theory. The diagram uses a horizontal pipeline structure with bidirectional arrows and explanatory callout boxes.
## 2. Component Analysis
### A. Main Pipeline (Header Row)
The top section consists of five rectangular nodes connected by double-headed (bidirectional) horizontal arrows, indicating equivalence or bidirectional reduction between the concepts.
| Sequence (Left to Right) | Text Label |
| :--- | :--- |
| Node 1 | **BwK** |
| Node 2 | **Linear Program** |
| Node 3 | **Lagrange game** |
| Node 4 | **Repeated game** |
| Node 5 | **BwK** |
### B. Explanatory Callouts (Lower Row)
Beneath the arrows connecting the main nodes are four pentagonal "house-shaped" callout boxes. These boxes provide the mathematical justification or the specific mechanism that links the two nodes above them.
| Position (Between Nodes) | Transcribed Text | Mathematical/Technical Content |
| :--- | :--- | :--- |
| Between **BwK** & **Linear Program** | Linear relaxation: $OPT_{LP} \geq OPT$ | Describes the relationship where the Linear Programming relaxation provides an upper bound for the optimal solution. |
| Between **Linear Program** & **Lagrange game** | Lagrange functions: $GameValue = OPT_{LP}$ | Establishes the equivalence between the value of the Lagrange game and the LP optimum. |
| Between **Lagrange game** & **Repeated game** | Learning in games: $Average\ play \approx Nash$ | Indicates that iterative learning in a repeated game converges toward a Nash equilibrium. |
| Between **Repeated game** & **BwK** | Large reward @stopping time | Relates the cumulative rewards of the game back to the original BwK problem constraints. |
## 3. Logical Flow and Trends
The diagram represents a circular or "full-circle" reduction proof.
1. **Trend:** The flow starts at **BwK** (left) and moves through increasingly abstract mathematical formulations (**Linear Programming** $\rightarrow$ **Lagrange Game** $\rightarrow$ **Repeated Game**) before returning to the original **BwK** problem (right).
2. **Bidirectionality:** Every connection is marked with a double-headed arrow, signifying that the properties of one domain can be mapped directly onto the next.
3. **Key Insight:** The diagram suggests that solving a Bandits with Knapsacks problem can be approached by treating it as a Linear Program, converting that LP into a Lagrange game, solving that game via repeated play (learning), and then interpreting those results back in the context of the original BwK rewards and stopping times.
## 4. Spatial Grounding
* **Header Region:** Contains the primary nodes [BwK, Linear Program, Lagrange game, Repeated game, BwK].
* **Transition Region:** Contains the bidirectional arrows and the pentagonal callouts centered under the spaces between the header nodes.
* **Language:** All text is in **English**, utilizing standard mathematical notation (subscripts, Greek/Latin abbreviations like OPT and LP, and symbols like $\geq$ and $\approx$).
</details>
Figure 6: The approach in $\mathtt{LagrangeBwK}$ .
Preliminaries
We will use the following notation. Let $r(a)$ be the expected per-round reward of arm $a$ , and $c_{i}(a)$ be the expected per-round consumption of a given resource $i$ . The sets of rounds, arms and resources are denoted $[T]$ , $[K]$ and $[d]$ , respectively. The distributions over arms and resources are denoted $\Delta_{K}$ and $\Delta_{d}$ . The adjusted total reward of algorithm $\mathtt{ALG}$ is denoted $\mathtt{REW}(\mathtt{ALG})$ .
Let $B=\min_{iâ[d]}B_{i}$ be the smallest budget. Without loss of generality, we rescale the problem so that all budgets are $B$ . For this, divide the per-round consumption of each resource $i$ by $B_{i}/B$ . In particular, the per-round consumption of the time resource is now $B/T$ .
We posit that one of the arms, called the null arm, brings no reward and consumes no resource except the âtime resourceâ. Playing this arm is tantamount to skipping a round. The presence of such arm is essential for several key steps in the analysis. In dynamic pricing the largest possible price is usually assumed to result in no sale, and therefore can be identified with the null arm.
**Remark 10.3**
*Even when skipping rounds is not allowed, existence of the null arm comes without loss of generality. This is because, whenever the null arm is chosen, an algorithm can proceed to the next round internally, without actually outputting an action. After $T$ rounds have passed from the algorithmâs perspective, the algorithm can choose arms arbitrarily, which can only increase the total reward.*
**Remark 10.4**
*Without loss of generality, the outcome vectors are chosen as follows. In each round $t$ , the outcome matrix $\mathbf{M}_{t}â[0,1]^{KĂ(d+1)}$ is drawn from some fixed distribution. Rows of $\mathbf{M}_{t}$ correspond to arms: for each arm $aâ[K]$ , the $a$ -th row of $\mathbf{M}_{t}$ is
| | $\displaystyle\mathbf{M}_{t}(a)=(r_{t}(a);\,c_{t,1}(a)\,,\ ...\ ,c_{t,d}(a)),$ | |
| --- | --- | --- |
so that $r_{t}(a)$ is the reward and $c_{t,i}(a)$ is the consumption of each resource $i$ . The round- $t$ outcome vector is defined as the $a_{t}$ -th row of this matrix: $\vec{o}_{t}=\mathbf{M}_{t}(a_{t})$ . Only this row is revealed to the algorithm.*
Step 1: Linear relaxation
Let us define a relaxation of $\mathtt{BwK}$ as follows. Fix some distribution $D$ over arms. Suppose this distribution is used in a given round, i.e., the arm is drawn independently from $D$ . Let $r(D)$ be the expected reward, and $c_{i}(D)$ be the expected per-round consumption of each resource $i$ :
$$
\textstyle r(D)=\sum_{a\in[K]}\;D(a)\;r(a)\quad\text{and}\quad c_{i}(D)=\sum_{a\in[K]}\;D(a)\;c_{i}(a).
$$
In the relaxation distribution $D$ is used in each round, and the reward and resource- $i$ consumption are deterministically equal to $r(D)$ and $c_{i}(D)$ , respectively. We are only interested in distributions $D$ such that the algorithm does not run out of resources until round $T$ . The problem of choosing $D$ so as to maximize the per-round reward in the relaxation can be formulated as a linear program:
$$
\begin{array}[]{ll}\text{maximize}&r(D)\\
\text{subject to}\\
&D\in\Delta_{K}\\
&T\cdot c_{i}(D)\leq B\qquad\forall i\in[d].\end{array} \tag{141}
$$
The value of this linear program is denoted $\mathtt{OPT}_{\mathtt{LP}}$ . We claim that the corresponding total reward, $T·\mathtt{OPT}_{\mathtt{LP}}$ , is an upper bound on $\mathtt{OPT}$ , the best expected reward achievable in $\mathtt{BwK}$ .
**Claim 10.5**
*$T·\mathtt{OPT}_{\mathtt{LP}}â„\mathtt{OPT}$ .*
* Proof*
Fix some algorithm $\mathtt{ALG}$ for $\mathtt{BwK}$ . Let $\tau$ be the round after which this algorithm stops. Without loss of generality, if $\tau<T$ then $\mathtt{ALG}$ continues to play the null arm in all rounds $\tau,\tau+1\,,\ ...\ ,T$ . Let $X_{t}(a)={\bf 1}_{\left\{\,a_{t}=a\,\right\}}$ be the indicator variable of the event that $\mathtt{ALG}$ chooses arm $a$ in round $t$ . Let $Dâ\Delta_{K}$ be the algorithmâs expected average play, as per Definition 9.2: i.e., for each arm $a$ , $D(a)$ is the expected fraction of rounds in which this arm is chosen. First, we claim that the expected total adjusted reward is $\operatornamewithlimits{\mathbb{E}}[\mathtt{REW}(\mathtt{ALG})]=r(D)$ . Indeed,
| | $\displaystyle\operatornamewithlimits{\mathbb{E}}[r_{t}]$ | $\displaystyle=\textstyle\sum_{aâ[K]}\;\Pr[a_{t}=a]·\operatornamewithlimits{\mathbb{E}}[r_{t}\mid a_{t}=a]$ | |
| --- | --- | --- | --- | Similarly, the expected total consumption of each resource $i$ is $\sum_{tâ[T]}\operatornamewithlimits{\mathbb{E}}[c_{t,i}]=T· c_{i}(D)$ . Since the (modified) algorithm does not stop until time $T$ , we have $\sum_{tâ[T]}c_{i,t}†B$ , and consequently $c_{i}(D)†B/T$ . Therefore, $D$ is a feasible solution for the linear program (141). It follows that $\operatornamewithlimits{\mathbb{E}}[\mathtt{REW}(\mathtt{ALG})]=r(D)â€\mathtt{OPT}_{\mathtt{LP}}$ . â
Step 2: Lagrange functions
Consider the Lagrange function associated with the linear program (141). For our purposes, this function inputs a distribution $D$ over arms and a distribution $\lambda$ over resources,
$$
\displaystyle\mathcal{L}(D,\lambda):=r(D)+\sum_{i\in[d]}\lambda_{i}\left[1-\tfrac{T}{B}\;c_{i}(D)\right]. \tag{142}
$$
Define the Lagrange game: a zero-sum game, where the primal player chooses an arm $a$ , the dual player chooses a resource $i$ , and the payoff is given by the Lagrange function:
$$
\displaystyle\mathcal{L}(a,i)=r(a)+1-\tfrac{T}{B}\;c_{i}(a). \tag{143}
$$
The primal player receives this number as a reward, and the dual player receives it as cost. The two players move simultaneously, without observing one another.
**Remark 10.6**
*The terms primal player and dual player are inspired by the duality in linear programming. For each linear program (LP), a.k.a. primal LP, there is an associated dual LP. Variables in (141) correspond to arms, and variables in its dual LP correspond to resources. Thus, the primal player chooses among the variables in the primal LP, and the dual player chooses among the variables in the dual LP.*
The Lagrangian game is related to the linear program, as expressed by the following lemma.
**Lemma 10.7**
*Suppose $(D^{*},\lambda^{*})$ is a mixed Nash equilibrium for the Lagrangian game. Then
- $1-\tfrac{T}{B}\,c_{i}(D^{*})â„ 0$ for each resource $i$ , with equality if $\lambda_{i}^{*}>0$ .
- $D^{*}$ is an optimal solution for the linear program (141).
- The minimax value of the Lagrangian game equals the LP value: $\mathcal{L}(D^{*},\lambda^{*})=\mathtt{OPT}_{\mathtt{LP}}$ .*
**Remark 10.8**
*Lagrange function is a standard notion in mathematical optimization. For an arbitrary linear program (with at least one solution and a finite LP value), the function satisfies a max-min property:
$$
\displaystyle\min_{\lambda\in\mathbb{R}^{d},\;\lambda\geq 0}\;\max_{D\in\Delta_{K}}\mathcal{L}(D,\lambda)=\max_{D\in\Delta_{K}}\;\min_{\lambda\in\mathbb{R}^{d},\;\lambda\geq 0}\mathcal{L}(D,\lambda)=\mathtt{OPT}_{\mathtt{LP}}. \tag{144}
$$
Because of the special structure of (141), we obtain the same property with $\lambdaâ\Delta_{d}$ .*
**Remark 10.9**
*In what follows, we only use part (c) of Lemma 10.7. Parts (ab) serve to prove (c), and are stated for intuition only. The property in part (a) is known as complementary slackness. The proof of Lemma 10.7 is a standard linear programming argument, not something about multi-armed bandits.*
* Proof of Lemma10.7*
By the definition of the mixed Nash equilibrium,
$$
\mathcal{L}(D^{*},\lambda)\geq\mathcal{L}(D^{*},\lambda^{*})\geq\mathcal{L}(D,\lambda^{*})\qquad\forall D\in\Delta_{K},\lambda\in\Delta_{d}. \tag{145}
$$ Part (a). First, we claim that $Y_{i}:=1-\tfrac{T}{B}\,c_{i}(D^{*})â„ 0$ for each resource $i$ with $\lambda^{*}_{i}=1$ . To prove this claim, assume $i$ is not the time resource (otherwise $c_{i}(D^{*})=B/T$ , and we are done). Fix any arm $a$ , and consider the distribution $D$ over arms which assigns probability $0$ to arm $a$ , puts probability $D^{*}(\mathtt{null})+D^{*}(a)$ on the null arm, and coincides with $D^{*}$ on all other arms. Using Eq. (145),
| | $\displaystyle 0$ | $\displaystyleâ€\mathcal{L}(D^{*},\lambda^{*})-\mathcal{L}(D,\lambda^{*})$ | |
| --- | --- | --- | --- |
Summing over all arms, we obtain $Y_{i}â„ 0$ , claim proved. Second, we claim that $Y_{i}â„ 0$ all resources $i$ . Suppose this is not the case. Focus on resource $i$ with the smallest $Y_{i}<0$ ; note that $\lambda^{*}_{i}<1$ by the first claim. Consider putting all probability on this resource: we have $\mathcal{L}(D^{*},i)<0=\mathcal{L}(D^{*},\mathtt{time})â€\mathcal{L}(D^{*},\lambda^{*})$ , contradicting (145). Third, assume that $\lambda_{i}^{*}>0$ and $Y_{i}>0$ for some resource $i$ . Then $\mathcal{L}(D^{*},\lambda^{*})>r(D^{*})$ . Now, consider distribution $\lambda$ which puts probability $1$ on the dummy resource. Then $\mathcal{L}(D^{*},\lambda)=r(D^{*})<\mathcal{L}(D^{*},\lambda^{*})$ , contradicting (145). Thus, $\lambda_{i}^{*}=0$ implies $Y_{i}>0$ . Part (bc). By part (a), $D^{*}$ is a feasible solution to (141), and $\mathcal{L}(D^{*},\lambda^{*})=r(D^{*})$ . Let $D$ be some other feasible solution for (141). Plugging in the feasibility constraints for $D$ , we have $\mathcal{L}(D,\lambda^{*})â„ r(D)$ . Then
$$
r(D^{*})=\mathcal{L}(D^{*},\lambda^{*})\geq\mathcal{L}(D,\lambda^{*})\geq r(D).
$$
So, $D^{*}$ is an optimal solution to the $\mathtt{LP}$ . In particular, $\mathtt{OPT}_{\mathtt{LP}}=r(D^{*})=\mathcal{L}(D^{*},\lambda^{*})$ . â
Step 3: Repeated Lagrange game
The round- $t$ outcome matrix $\mathbf{M}_{t}$ , as defined in Remark 10.4, defines the respective Lagrange function $\mathcal{L}_{t}$ :
$$
\displaystyle\mathcal{L}_{t}(a,i)=r_{t}(a)+1-\tfrac{T}{B}\;c_{t,i}(a),\quad a\in[K],\,i\in[d]. \tag{146}
$$
Note that $\operatornamewithlimits{\mathbb{E}}[\mathcal{L}_{t}(a,i)]=\mathcal{L}(a,i)$ , so we will refer to $\mathcal{L}$ as the expected Lagrange function.
**Remark 10.10**
*The function defined in (146) is a Lagrange function for the appropriate âround- $t$ versionâ of the linear program (141). Indeed, consider the expected outcome matrix $\mathbf{M}_{\mathtt{exp}}:=\operatornamewithlimits{\mathbb{E}}[\mathbf{M}_{t}]$ , which captures the expected per-round rewards and consumptions, The $a$ -th row of $\mathbf{M}_{\mathtt{exp}}$ is $(r(a);\,c_{1}(a)\,,\ ...\ ,c_{d}(a))$ , for each arm $aâ[K]$ . and therefore defines the LP. Let us instead plug in an arbitrary outcome matrix $\mathbf{M}â[0,1]^{KĂ(d+1)}$ instead of $\mathbf{M}_{\mathtt{exp}}$ . Formally, let $\mathtt{LP}_{\mathbf{M}}$ be a version of (141) when $\mathbf{M}_{\mathtt{exp}}=\mathbf{M}$ , and let $\mathcal{L}_{\mathbf{M}}$ be the corresponding Lagrange function. Then $\mathcal{L}_{t}=\mathcal{L}_{\mathbf{M}_{t}}$ for each round $t$ , i.e., $\mathcal{L}_{t}$ is the Lagrange function for the version of the LP induced by the round- $t$ outcome matrix $\mathbf{M}_{t}$ .*
The repeated Lagrange game is a game between two algorithms, the primal algorithm $\mathtt{ALG}_{1}$ and the dual algorithm $\mathtt{ALG}_{2}$ , which proceeds over $T$ rounds. In each round $t$ , the primal algorithm chooses arm $a_{t}$ , the dual algorithm chooses a resource $i_{t}$ , and the payoff â primal playerâs reward and dual playerâs cost â equals $\mathcal{L}_{t}(a_{t},i_{t})$ . The two algorithms make their choices simultaneously, without observing one another.
Our algorithm, called $\mathtt{LagrangeBwK}$ , is very simple: it is a repeated Lagrangian game in which the primal algorithm receives bandit feedback, and the dual algorithm receives full feedback. The pseudocode, summarized in Algorithm 1, is self-contained: it specifies the algorithm even without defining repeated games and Lagrangian functions. The algorithm is implementable, in the sense that the outcome vector $\vec{o}_{t}$ revealed in each round $t$ of the $\mathtt{BwK}$ problem suffices to generate the feedback for both $\mathtt{ALG}_{1}$ and $\mathtt{ALG}_{2}$ .
Given : time horizon $T$ , budget $B$ , number of arms $K$ , number of resources $d$ .
Bandit algorithm $\mathtt{ALG}_{1}$ : action set $[K]$ , maximizes rewards, bandit feedback.
Bandit algorithm $\mathtt{ALG}_{2}$ : action set $[d]$ , minimizes costs, full feedback.
for round $t=1,2,\,...$ (until stopping) do
$\mathtt{ALG}_{1}$ returns arm $a_{t}â[K]$ , algorithm $\mathtt{ALG}_{2}$ returns resource $i_{t}â[d]$ .
Arm $a_{t}$ is chosen, outcome vector $\vec{o}_{t}=(r_{t}(a_{t});c_{t,1}(a_{t})\,,\ ...\ ,c_{t,d}(a_{t}))â[0,1]^{d+1}$ is observed.
The payoff $\mathcal{L}_{t}(a_{t},i_{t})$ from (146) is reported to $\mathtt{ALG}_{1}$ as reward, and to $\mathtt{ALG}_{2}$ as cost.
The payoff $\mathcal{L}_{t}(a_{t},i)$ is reported to $\mathtt{ALG}_{2}$ for each resource $iâ[d]$ .
end for
Algorithm 1 Algorithm $\mathtt{LagrangeBwK}$
Let us apply the machinery from Section 9 to the repeated Lagrangian game. For each algorithm $\mathtt{ALG}_{j}$ , $jâ\{1,2\}$ , we are interested in its regret $R_{j}(T)$ relative to the best-observed action, as defined in Chapter 25. We will call it adversarial regret throughout this chapter, to distinguish from the regret in $\mathtt{BwK}$ . For each round $\tauâ[T]$ , let $\bar{a}â\Delta_{K}$ and $\bar{\imath}â\Delta_{d}$ be the average play of $\mathtt{ALG}_{1}$ and $\mathtt{ALG}_{2}$ , resp., up to round $\tau$ , as per Definition 9.2. Now, Exercise 9.4, applied for the time horizon $\tauâ[T]$ , implies the following:
**Lemma 10.11**
*For each round $\tauâ[T]$ , the average play $(\bar{a}_{\tau},\bar{\imath}_{\tau})$ forms a $\delta_{\tau}$ -approximate Nash equilibrium for the expected Lagrange game defined by $\mathcal{L}$ , where
$$
\tau\cdot\delta_{\tau}=R_{1}(\tau)+R_{2}(\tau)+\mathtt{err}_{\tau},\text{ with error term }\textstyle\mathtt{err}_{\tau}:=\left|\sum_{t\in[\tau]}\mathcal{L}_{t}(i_{t},j_{t})-\mathcal{L}(i_{t},j_{t})\right|.
$$*
**Corollary 10.12**
*$\mathcal{L}(\bar{a}_{\tau},i)â„\mathtt{OPT}_{\mathtt{LP}}-\delta_{\tau}$ for each resource $i$ .*
Step 4: Reward at the stopping time
We focus on the stopping time $\tau$ , the first round when the total consumption of some resource $i$ exceeds its budget; call $i$ the stopping resource. We argue that $\mathtt{REW}$ is large compared to $\mathcal{L}(\bar{a}_{\tau},i)$ (which plugs nicely into Corollary 10.12). In fact, this step holds for any $\mathtt{BwK}$ algorithm.
**Lemma 10.13**
*For an arbitrary $\mathtt{BwK}$ algorithm $\mathtt{ALG}$ ,
$$
\mathtt{REW}(\mathtt{ALG})\geq\tau\cdot\mathcal{L}(\bar{a}_{\tau},i)+(T-\tau)\cdot\mathtt{OPT}_{\mathtt{LP}}-\mathtt{err}^{*}_{\tau,i},
$$
where $\mathtt{err}^{*}_{\tau,i}:=\left|\tau· r(\bar{a}_{\tau})-\sum_{tâ[\tau]}r_{t}\right|+\tfrac{T}{B}\,\left|\tau· c_{i}(\bar{a}_{\tau})-\sum_{tâ[\tau]}c_{i,t}\right|$ is the error term.*
* Proof*
Note that $\sum_{tâ[\tau]}c_{t,i}>B$ because of the stopping. Then:
| | $\displaystyle\tau·\mathcal{L}(\bar{a}_{\tau},i)$ | $\displaystyle=\tau·\left(r(\bar{a})+1-\tfrac{T}{B}c_{i}(\bar{a})\right)$ | |
| --- | --- | --- | --- |
The Lemma follows since $\mathtt{OPT}_{\mathtt{LP}}†1$ . â
Plugging in Corollary 10.12, the analysis is summarized as follows:
$$
\displaystyle\mathtt{REW}(\mathtt{LagrangeBwK})\geq T\cdot\mathtt{OPT}_{\mathtt{LP}}-\left[\;R_{1}(\tau)+R_{2}(\tau)+\mathtt{err}_{\tau}+\mathtt{err}^{*}_{\tau,i}\;\right], \tag{147}
$$
where $\tau$ is the stopping time and $i$ is the stopping resource.
Wrapping up
It remains to bound the error/regret terms in (147). Since the payoffs in the Lagrange game lie in the range $[a,b]:=[1-\tfrac{T}{B},2]$ , all error/regret terms are scaled up by the factor $b-a=1+\tfrac{T}{B}$ .
Fix an arbitrary failure probability $\delta>0$ . An easy application of Azuma-Hoeffding Bounds implies that
$$
\textstyle\mathtt{err}_{\tau}+\mathtt{err}^{*}_{\tau,i}\leq O(b-a)\cdot\sqrt{TK\log\left(\frac{dT}{\delta}\right)}\qquad\forall\tau\in[T],\,i\in[d],
$$
with probability at least $1-\delta$ . (Apply Azuma-Hoeffding to each $\mathtt{err}_{\tau}$ and $\mathtt{err}^{*}_{\tau,i}$ separately. )
Let use use algorithms $\mathtt{ALG}_{1}$ and $\mathtt{ALG}_{2}$ that admit high-probability upper bounds on adversarial regret. For $\mathtt{ALG}_{1}$ , we use algorithm $\mathtt{EXP3.P.1}$ from Auer et al. (2002b), and for $\mathtt{ALG}_{2}$ we use a version of algorithm $\mathtt{Hedge}$ from Chapter 27. With these algorithms, with probability at least $1-\delta$ it holds that, for each $\tauâ[T]$ ,
| | $\displaystyle R_{1}(\tau)$ | $\displaystyle\textstyle†O(b-a)·\sqrt{TK\log\left(\frac{T}{\delta}\right)},$ | |
| --- | --- | --- | --- |
Plugging this into (147), we obtain the main result for $\mathtt{LagrangeBwK}$ .
**Theorem 10.14**
*Suppose algorithm $\mathtt{LagrangeBwK}$ is used with $\mathtt{EXP3.P.1}$ as $\mathtt{ALG}_{1}$ , and $\mathtt{Hedge}$ as $\mathtt{ALG}_{2}$ . Then the following regret bound is achieved, with probability at least $1-\delta$ :
| | $\displaystyle\textstyle\mathtt{OPT}-\mathtt{REW}†O\left(\,\nicefrac{{T}}{{B}}\,\right)·\sqrt{TK\ln\left(\,\frac{dT}{\delta}\,\right)}.$ | |
| --- | --- | --- |*
This regret bound is optimal in the worst case, up to logarithmic factors, in the regime when $B=\Omega(T)$ . This is because of the $\Omega(\sqrt{KT})$ lower bound for stochastic bandits. However, as we will see next, this regret bound is not optimal when $\min(B,\mathtt{OPT})\ll T$ .
$\mathtt{LagrangeBwK}$ achieves optimal $\tilde{O}(KT)$ regret on problem instances with zero resource consumption, i.e., the $\nicefrac{{T}}{{B}}$ factor in the regret bound vanishes, see Exercise 10.4.
58 Optimal algorithms and regret bounds (no proofs)
The optimal regret bound is in terms of (unknown) optimum $\mathtt{OPT}$ and budget $B$ rather than time horizon $T$ :
$$
\displaystyle\mathtt{OPT}-\operatornamewithlimits{\mathbb{E}}[\mathtt{REW}]\leq\tilde{O}\left(\sqrt{K\cdot\mathtt{OPT}}+\mathtt{OPT}\sqrt{K/B}\right). \tag{148}
$$
This regret bound is essentially optimal for any given triple $(K,B,T)$ : no algorithm can achieve better regret, up to logarithmic factors, over all problem instances with these $(K,B,T)$ . More precisely, no algorithm can achieve regret $\Omega(\min(\mathtt{OPT},\mathtt{reg}))$ , where $\mathtt{reg}=\sqrt{K·\mathtt{OPT}}+\mathtt{OPT}\sqrt{K/B}$ . The first summand is essentially regret from stochastic bandits, and the second summand is due to the global constraints. The dependence on $d$ is only logarithmic.
We obtain regret $\tilde{O}(\sqrt{KT})$ when $B>\Omega(T)$ , like in Theorem 10.14. We have an improvement when $\mathtt{OPT}/\sqrt{B}\ll\sqrt{T}$ : e.g., $\mathtt{OPT}†B$ in the dynamic pricing example described above, so we obtain regret $\tilde{O}(\sqrt{KB})$ if there are only $K$ feasible prices. The bad case is when budget $B$ is small, but $\mathtt{OPT}$ is large.
Below we outline two algorithms that achieve the optimal regret bound in (148). More precisely, Algorithm 2 achieves the regret bound (148) with an extra multiplicative term of $\sqrt{d}$ . These algorithms build on techniques from IID bandits: resp., Successive Elimination and Optimism under Uncertainty (see Chapter 1). We omit their analyses, which are very detailed and not as lucid as the one for $\mathtt{LagrangeBwK}$ .
Prepwork
We consider outcome matrices: formally, these are matrices in $[0,1]^{KĂ(d+1)}$ . The round- $t$ outcome matrix $\mathbf{M}_{t}$ is defined as per Remark 10.4, and the expected outcome matrix is $\mathbf{M}_{\mathtt{exp}}=\operatornamewithlimits{\mathbb{E}}[\mathbf{M}_{t}]$ .
Both algorithms maintain a confidence region on $\mathbf{M}_{\mathtt{exp}}$ : a set of outcome matrices which contains $\mathbf{M}_{\mathtt{exp}}$ with probability at least $1-T^{-2}$ . In each round $t$ , the confidence region $\mathtt{ConfRegion}_{t}$ is recomputed based on the data available in this round. More specifically, a confidence interval is computed separately for each âentryâ of $\mathbf{M}_{\mathtt{exp}}$ , and $\mathtt{ConfRegion}_{t}$ is defined as a product set of these confidence intervals.
Given a distribution $D$ over arms, consider its value in the linear program (141):
$$
\mathtt{LP}(D\mid B,\mathbf{M}_{\mathtt{exp}})=\begin{cases}r(D)&\text{if $c_{i}(D)\leq B/T$ for each resource $i$},\\
0&\text{otherwise}.\end{cases}
$$
We use a flexible notation which allows to plug in arbitrary outcome matrix $\mathbf{M}_{\mathtt{exp}}$ and budget $B$ .
Algorithm I: Successive Elimination with Knapsacks
We look for optimal distributions over arms. A distribution $D$ is called potentially optimal if it optimizes $\mathtt{LP}(D\mid B,\mathbf{M})$ for some $\mathbf{M}â\mathtt{ConfRegion}_{t}$ . In each round, we choose a potentially optimal distribution, which suffices for exploitation. But which potentially optimal distribution to choose so as to ensure sufficient exploration? Intuitively, we would like to explore each arm as much as possible, given the constraint that we can only use potentially optimal distributions. We settle for something almost as good: we choose an arm $a$ uniformly at random, and then explore it as much as possible, in the sense that we choose a potentially optimal distribution $D$ that maximizes $D(a)$ . See Algorithm 2 for the pseudocode.
for round $t=1,2,\,...$ (until stopping) do
$S_{t}â$ the set of all potentially optimal distributions over arms.
Pick arm $b_{t}$ uniformly at random.
Pick a distribution $D=D_{t}$ so as to maximize $D(b_{t})$ over all $Dâ S_{t}$ .
Pick arm $a_{t}\sim D_{t}$ .
end for
Algorithm 2 Successive Elimination with Knapsacks
**Remark 10.15**
*The step of maximizing $D(b_{t})$ does not have a computationally efficient implementation (more precisely, such implementation is not known for the general case of $\mathtt{BwK}$ ).*
This algorithm can be seen as an extension of Successive Elimination. Recall that in Successive Elimination, we start with all arms being âactiveâ and permanently de-activate a given arm $a$ once we have high-confidence evidence that some other arm is better. The idea is that each arm that is currently active can potentially be an optimal arm given the evidence collected so far. In each round we choose among arms that are still âpotentially optimalâ, which suffices for the purpose of exploitation. And choosing uniformly (or round-robin) among the potentially optimal arms suffices for the purpose of exploration.
Algorithm II: Optimism under Uncertainty
For each round $t$ and each distribution $D$ over arms, define the Upper Confidence Bound as
$$
\displaystyle\mathtt{UCB}_{t}(D\mid B)=\sup_{\mathbf{M}\in\mathtt{ConfRegion}_{t}}\mathtt{LP}(D\mid B,\mathbf{M}). \tag{149}
$$
The algorithm is very simple: in each round, the algorithm picks distribution $D$ which maximizes the UCB. An additional trick is to pretend that all budgets are scaled down by the same factor $1-\epsilon$ , for an appropriately chosen parameter $\epsilon$ . This trick ensures that the algorithm does not run out of resources too soon due to randomness in the outcomes or to the fact that the distributions $D_{t}$ do not quite achieve the optimal value for $\mathtt{LP}(D)$ . The algorithm, called $\mathtt{UcbBwK}$ , is as follows:
Rescale the budget: $B^{\prime}â B(1-\epsilon)$ , where $\epsilon=\tilde{\Theta}(\sqrt{K/B})$
Initialization: pull each arm once.
for all subsequent rounds $t$ do
In each round $t$ , pick distribution $D=D_{t}$ with highest $\mathtt{UCB}_{t}(·\mid B^{\prime})$ .
Pick arm $a_{t}\sim D_{t}$ .
end for
Algorithm 3 $\mathtt{UcbBwK}$ : Optimism under Uncertainty with Knapsacks.
**Remark 10.16**
*For a given distribution $D$ , the supremum in (149) is obtained when upper confidence bounds are used for rewards, and lower confidence bounds are used for resource consumption:
| | $\displaystyle\mathtt{UCB}_{t}(D\mid B^{\prime})=\begin{cases}r^{\mathtt{UCB}}(D)&\text{if $c^{\mathtt{LCB}}_{i}(D)†B^{\prime}/T$ for each resource $i$},\\
0&\text{otherwise}.\end{cases}$ | |
| --- | --- | --- |
Accordingly, choosing a distribution with maximal $\mathtt{UCB}$ can be implemented by a linear program:
$$
\begin{array}[]{ll}\text{maximize}&r^{\mathtt{UCB}}(D)\\
\text{subject to}\\
&D\in\Delta_{K}\\
&c_{i}^{\mathtt{LCB}}(D)\leq B^{\prime}/T.\end{array} \tag{150}
$$*
59 Literature review and discussion
The general setting of $\mathtt{BwK}$ is introduced in Badanidiyuru et al. (2013, 2018), along with an optimal solution (148), the matching lower bound, and a detailed discussion of various motivational examples. (The lower bound is also implicit in earlier work of Devanur et al. (2019).) $\mathtt{LagrangeBwK}$ , the algorithm this chapter focuses on, is from a subsequent paper (Immorlica et al., 2022). Cardoso et al. (2018), in a simultaneous and independent work, put forward a similar algorithm, and analyze it under full feedback for the setting of âbandit convex optimization with knapsacksâ (see Section 59.2). This algorithm is in fact a âreductionâ from $\mathtt{BwK}$ to bandits (see Section 59.1), and also âworksâ for the adversarial version (see Section 59.4)
Various motivating applications of $\mathtt{BwK}$ have been studied separately: dynamic pricing (Besbes and Zeevi, 2009; Babaioff et al., 2015a; Besbes and Zeevi, 2012; Wang et al., 2014), dynamic procurement (Badanidiyuru et al., 2012; Singla and Krause, 2013), and pay-per-click ad allocation (Slivkins, 2013; Combes et al., 2015). Much of this work preceded and inspired Badanidiyuru et al. (2013).
The optimal regret bound in (148) has been achieved by three different algorithms: the two in Section 58 and one other algorithm from Badanidiyuru et al. (2013, 2018). The successive elimination-based algorithm (Algorithm 2) is from (Badanidiyuru et al., 2013, 2018), and $\mathtt{UcbBwK}$ (Algorithm 3) is from a follow-up paper of Agrawal and Devanur (2014, 2019). The third algorithm, also from (Badanidiyuru et al., 2013, 2018), is a âprimal-dualâ algorithm superficially similar to $\mathtt{LagrangeBwK}$ . Namely, it decouples into two online learning algorithms: a âprimalâ algorithm which chooses among arms, and a âdualâ algorithm similar to $\mathtt{ALG}_{2}$ , which chooses among resources. However, the primal and dual algorithms are not playing a repeated game in any meaningful sense. Moreover, the primal algorithm is very problem-specific: it interprets the dual distribution as a vector of costs over resources, and chooses arms with largest reward-to-cost ratios, estimated using âoptimism under uncertaintyâ.
Some of the key ideas in $\mathtt{BwK}$ trace back to earlier work. In addition to the zero-sum games machinery from Chapter 9 and stochastic bandit techniques from Chapter 1. First, focusing on total expected rewards rather than per-round expected rewards, approximating total expected rewards with a linear program, and using âoptimisticâ estimates of the LP values in a UCB-style algorithm goes back to Babaioff et al. (2015a). They studied the special case of dynamic pricing with limited supply, and applied these ideas to fixed arms (not distributions over arms). Second, repeated Lagrange games, in conjunction with regret minimization in zero-sum games, have been used as an algorithmic tool to solve various convex optimization problems (different from $\mathtt{BwK}$ ), with application domains ranging from differential privacy to algorithmic fairness to learning from revealed preferences (Rogers et al., 2015; Hsu et al., 2016; Roth et al., 2016; Kearns et al., 2018; Agarwal et al., 2017a; Roth et al., 2017). All these papers deal with deterministic games (i.e., same game matrix in all rounds). Most related are (Roth et al., 2016, 2017), where a repeated Lagrangian game is used as a subroutine (the âinner loopâ) in an online algorithm; the other papers solve an offline problem. Third, estimating an optimal âdualâ vector from samples and using this vector to guide subsequent âprimalâ decisions is a running theme in the work on stochastic packing problems (Devanur and Hayes, 2009; Agrawal et al., 2014; Devanur et al., 2019; Feldman et al., 2010; Molinaro and Ravi, 2012). These are full information problems in which the costs and rewards of decisions in the past and present are fully known, and the only uncertainty is about the future. Particularly relevant is the algorithm of Devanur et al. (2011), in which the dual vector is adjusted using multiplicative updates, as in $\mathtt{LagrangeBwK}$ and the primal-dual algorithm from Badanidiyuru et al. (2013, 2018).
$\mathtt{BwK}$ with only one constrained resource and unlimited number of rounds tends to be an easier problem, avoiding much of the complexity of the general case. In particular, $\mathtt{OPT_{FD}}=\mathtt{OPT_{FA}}$ , i.e., the best distribution over arms is the same as the best fixed arm. György et al. (2007) and subsequently Tran-Thanh et al. (2010, 2012); Ding et al. (2013) obtain instance-dependent $\text{polylog}(T)$ regret bounds under various assumptions.
59.1 Reductions from $\mathtt{BwK}$ to bandits
Taking a step back from bandits with knapsacks, recall that global constrains is just one of several important âdimensionsâ in the problem space of multi-armed bandits. It is desirable to unify results on $\mathtt{BwK}$ with those on other âproblem dimensionsâ. Ideally, results on bandits would seamlessly translate into $\mathtt{BwK}$ . In other words, solving some extension of $\mathtt{BwK}$ should reduce to solving a similar extension of bandits. Such results are called reductions from one problem to another. $\mathtt{LagrangeBwK}$ and $\mathtt{UcbBwK}$ algorithms give rise to two different reductions from $\mathtt{BwK}$ to bandits, discussed below.
$\mathtt{LagrangeBwK}$ takes an arbitrary âprimalâ algorithm $\mathtt{ALG}_{1}$ , and turns it into an algorithm for $\mathtt{BwK}$ . To obtain an extension to a particular extension of $\mathtt{BwK}$ , algorithm $\mathtt{ALG}_{1}$ should work for this extension in bandits, and achieve a high-probability bound on its âadversarial regretâ $R_{1}(·)$ (provided that per-round rewars/costs lie in $[0,1]$ ). This regret bound $R_{1}(·)$ then plugs into Eq. (147) and propagates through the remaining steps of the analysis. Then with probability at least $1-\delta$ one has
$$
\displaystyle\textstyle\mathtt{OPT}-\mathtt{REW}\leq O\left(\,\nicefrac{{T}}{{B}}\,\right)\cdot\left(\,R_{1}(T)+\sqrt{TK\ln(dT/\delta)}\,\right). \tag{151}
$$
Immorlica et al. (2022) makes this observation and uses it to obtain several extensions: to contextual bandits, combinatorial semi-bandits, bandit convex optimization, and full feedback. (These and other extensions are discussed in detail in Section 59.2.)
The reduction via $\mathtt{UcbBwK}$ is different: it inputs a lemma about stochastic bandits, not an algorithm. This lemma works with an abstract confidence radius $\mathtt{rad}_{t}(·)$ , which generalizes that from Chapter 1. For each arm $a$ and round $t$ , $\mathtt{rad}_{t}(a)$ is a function of algorithmâs history which is an upper confidence bound for $|r(a)-\hat{r}_{t}(a)|$ and $|c_{i}(a)-\hat{c}_{t,i}(a)|$ , where $\hat{r}_{t}(a)$ and $\hat{c}_{t,i}(a)$ are some estimates computable from the data. The lemma asserts that for a particular version of confidence radius and any bandit algorithm it holds that
$$
\displaystyle\textstyle\sum_{t\in S}\mathtt{rad}_{t}(a_{t})\leq\sqrt{\beta\,|S|}\quad\text{for all subsets of rounds $S\subset[T]$}, \tag{152}
$$
where $\beta\ll K$ is some application-specific parameter. (The left-hand side is called the confidence sum.) Eq. (152) holds with $\beta=K$ for stochastic bandits; this follows from the analysis in Section 3.2, and stems from the original analysis of $\mathtt{UCB1}$ algorithm in Auer et al. (2002a). Similar results are known for several extensions of stochastic bandits: this is typically a key step in the analysis of any extension of $\mathtt{UCB1}$ algorithm. Whenever Eq. (152) holds for some extension of stochastic bandits, one can define a version of $\mathtt{UcbBwK}$ algorithm which uses $\hat{r}(a)+\mathtt{rad}_{t}(a)$ and $\hat{c}_{t,i}-\mathtt{rad}_{t}(a)$ as, resp., UCB on $r(a)$ and LCB on $c_{i}(a)$ in (150). Plugging (152) into the original analysis of $\mathtt{UcbBwK}$ in Agrawal and Devanur (2014, 2019) yields
$$
\displaystyle\mathtt{OPT}-\operatornamewithlimits{\mathbb{E}}[\mathtt{REW}]\leq O(\sqrt{\beta T})(1+\mathtt{OPT}/B). \tag{153}
$$
Sankararaman and Slivkins (2021) make this observation explicit, and apply it to derive extensions to combinatorial semi-bandits, linear contextual bandits, and multinomial-logit bandits.
Extensions via either approach take little or no extra work (when there is a result to reduce from), whereas many papers, detailed in Section 59.2, target one extension each. The resulting regret bounds are usually optimal in the regime when $\min(B,\mathtt{OPT})>\Omega(T)$ . Moreover, the $\mathtt{LagrangeBwK}$ reduction also âworksâ for the adversarial version (see Section 59.4).
However, these results come with several important caveats. First, the regret bounds can be suboptimal if $\min(B,\mathtt{OPT})\ll\Omega(T)$ , and may be improved upon via application-specific results. Second, algorithm $\mathtt{ALG}_{1}$ in $\mathtt{LagrangeBwK}$ needs a regret bound against an adaptive adversary, even though for $\mathtt{BwK}$ we only need an regret bound against stochastic outcomes. Third, this regret bound needs to hold for the rewards specified by the Lagrange functions, rather than the rewards in the underlying $\mathtt{BwK}$ problem (and the latter may have some useful properties that do not carry over to the former). Fourth, most results obtained via the $\mathtt{UcbBwK}$ reduction do not come with a computationally efficient implementation.
59.2 Extensions of $\mathtt{BwK}$
$\mathtt{BwK}$ with generalized resources. Agrawal and Devanur (2014, 2019) consider a version of $\mathtt{BwK}$ with a more abstract version of resources. First, they remove the distinction between rewards and resource consumption. Instead, in each round $t$ there is an outcome vector $o_{t}â[0,1]^{d}$ , and the âfinal outcomeâ is the average $\bar{o}_{T}=\tfrac{1}{T}\sum_{tâ[T]}o_{t}$ . The total reward is determined by $\bar{o}_{T}$ , in a very flexible way: it is $T· f(\bar{o}_{T})$ , for an arbitrary Lipschitz concave function $f:[0,1]^{d}\mapsto[0,1]$ known to the algorithm. Second, the resource constraints can be expressed by an arbitrary convex set $Sâ[0,1]^{d}$ which $\bar{o}_{T}$ must belong to. Third, they allow soft constraints: rather than requiring $\bar{o}_{t}â S$ for all rounds $t$ (hard constraints), they upper-bound the distance between $\bar{o}_{t}$ and $S$ . They obtain regret bounds that scale as $\sqrt{T}$ , with distance between $\bar{o}_{t}$ and $S$ scaling as $1/\sqrt{T}$ . Their results extend to the hard-constraint version by rescaling the budgets, as in Algorithm 3, as long as the constraint set $S$ is downward closed.
Contextual bandits with knapsacks. Contextual bandits with knapsacks (cBwK) is a common generalization of $\mathtt{BwK}$ and contextual bandits (background on the latter can be found in Chapter 8). In each round $t$ , an algorithm observes context $x_{t}$ before it chooses an arm. The pair $(x_{t},\mathbf{M}_{t})$ , where $\mathbf{M}_{t}â[0,1]^{KĂ(d+1)}$ is the round- $t$ outcome matrix, is chosen independently from some fixed distribution (which is included in the problem instance). The algorithm is given a set $\Pi$ of policies (mappings from arms to actions), as in Section 44. The benchmark is the best all-knowing algorithm restricted to policies in $\Pi$ : $\mathtt{OPT}_{\Pi}$ is the expected total reward of such algorithm, similarly to (137). The following regret bound can be achieved:
$$
\displaystyle\mathtt{OPT}_{\Pi}-\operatornamewithlimits{\mathbb{E}}[\mathtt{REW}]\leq\tilde{O}(1+\mathtt{OPT}_{\Pi}/B)\,\sqrt{KT\log|\Pi|}. \tag{154}
$$
The $\sqrt{KT\log(|\Pi|)}$ dependence on $K$ , $T$ and $\Pi$ is optimal for contextual bandits, whereas the $(1+\mathtt{OPT}_{\Pi}/B)$ term is due $\mathtt{BwK}$ . In particular, this regret bound is optimal in the regime $B>\Omega(\mathtt{OPT}_{\Pi})$ .
Badanidiyuru et al. (2014) achieve (154), with an extra factor of $\sqrt{d}$ , unifying Algorithm 2 and the policy elimination algorithm for contextual bandits (DudĂk et al., 2011). Like policy elimination, the algorithm in Badanidiyuru et al. (2014) does not come with a computationally efficient implementation. Subsequently, Agrawal et al. (2016) obtained (154) using an âoracle-efficientâ algorithm: it uses a classification oracle for policy class $\Pi$ as a subroutine, and calls this oracle only $\tilde{O}(d\sqrt{KT\log|\Pi|})$ times. Their algorithm builds on the contextual bandit algorithm from Agarwal et al. (2014), see Remark 8.10.
$\mathtt{LagrangeBwK}$ reduction can be applied, achieving regret bound
| | $\displaystyle\mathtt{OPT}_{\Pi}-\operatornamewithlimits{\mathbb{E}}[\mathtt{REW}]â€\tilde{O}(T/B)\,\sqrt{KT\log|\Pi|}.$ | |
| --- | --- | --- |
This regret rate matches (154) when $\mathtt{OPT}_{\Pi}>\Omega(T)$ , and is optimal in the regime $B>\Omega(T)$ . The âprimalâ algorithm $\mathtt{ALG}_{1}$ is $\mathtt{Exp4.P}$ from Beygelzimer et al. (2011), the high-probability version of algorithm $\mathtt{Exp4}$ from Section 33. Like $\mathtt{Exp4}$ , this algorithm is not computationally efficient.
In a stark contrast with $\mathtt{BwK}$ , non-trivial regret bounds are not necessarily achievable when $B$ and $\mathtt{OPT}_{\Pi}$ are small. Indeed, $o(\mathtt{OPT})$ worst-case regret is impossible in the regime $\mathtt{OPT}_{\Pi}†Bâ€\sqrt{KT}/2$ (Badanidiyuru et al., 2014). Whereas $o(\mathtt{OPT})$ regret bound holds for $\mathtt{BwK}$ whenever $B=\omega(1)$ , as per (148).
Slivkins et al. (2023) and Han et al. (2023) pursue an alternative approach whereby one posits realizability and applies a regression oracle (see Chapter 47). They combine $\mathtt{LagrangeBwK}$ and SquareCB, the regression-based algorithm for contextual bandits from Foster and Rakhlin (2020).
Linear contextual $\mathtt{BwK}$ . In the extension to linear contextual bandits (see Section 43), the expected outcome matrix is linear in the context $x_{t}$ , and all policies are allowed. Formally, each context is a matrix: $x_{t}â[0,1]^{KĂ m}$ , where rows correspond to arms, and each armâs context has dimension $m$ . The linear assumption states that $\operatornamewithlimits{\mathbb{E}}[\mathbf{M}_{t}\mid x_{t}]=x_{t}\,\mathbf{W}$ , for some matrix $\mathbf{W}â[0,1]^{(d+1)Ă m}$ that is fixed over time, but not known to the algorithm. Agrawal and Devanur (2016) achieve regret bound
$$
\displaystyle\mathtt{OPT}-\operatornamewithlimits{\mathbb{E}}[\mathtt{REW}]\leq\tilde{O}(m\sqrt{T})(1+\mathtt{OPT}/B)\qquad\text{in the regime $B>mT^{3/4}$}. \tag{155}
$$
The $\tilde{O}(m\sqrt{T})$ dependence is the best possible for linear bandits (Dani et al., 2008), whereas the $(1+\mathtt{OPT}/B)$ term and the restriction to $B>mT^{3/4}$ is due to $\mathtt{BwK}$ . In particular, this regret bound is optimal, up to logarithmic factors, in the regime $B>\Omega(\max(\mathtt{OPT},\,m\,T^{3/4}))$ .
Eq. (155) is immediately obtained via $\mathtt{UcbBwK}$ reduction, albeit without a computationally efficient implementation (Sankararaman and Slivkins, 2021).
Combinatorial semi-bandits with knapsacks. In the extension to combinatorial semi-bandits (see Section 38), there is a finite set $S$ of atoms, and a collection $\mathcal{F}$ of feasible subsets of $S$ . Arms correspond to the subsets in $\mathcal{F}$ . When an arm $a=a_{t}â\mathcal{F}$ is chosen in some round $t$ , each atom $iâ a$ collects a reward and consumes resources, with its outcome vector $v_{t,i}â[0,1]^{d+1}$ chosen independently from some fixed but unknown distribution. The âtotalâ outcome vector $\vec{o}_{t}$ is a sum over atoms: $\vec{o}_{t}=\sum_{iâ a}v_{t,i}$ . We have semi-bandit feedback: the outcome vector $v_{t,i}$ is revealed to the algorithm, for each atom $iâ a$ . The central theme is that, while the number of arms, $K=|\mathcal{F}|$ , may be exponential in the number of atoms, $m=|S|$ , one can achieve regret bounds that are polynomial in $m$ .
Combinatorial semi-bandits with knapsacks is a special case of linear cBwK, as defined above, where the context $x_{t}$ is the same in all rounds, and defines the collection $\mathcal{F}$ . (For each arm $aâ\mathcal{F}$ , the $a$ -th row of $x_{t}$ is a binary vector that represents $a$ .) Thus, the regret bound (155) for linear cBwK applies. Sankararaman and Slivkins (2018) achieve an improved regret bound when the set system $\mathcal{F}$ is a matroid. They combine Algorithm 3 with the randomized rounding techniques from approximation algorithms. In the regime when $\min(B,\mathtt{OPT})>\Omega(T)$ , these two regret bounds become, respectively, $\tilde{O}(m\sqrt{T})$ and $\tilde{O}(\sqrt{mT})$ . The $\sqrt{mT}$ regret is optimal, up to constant factors, even without resources (Kveton et al., 2014).
Both reductions from Section 59.1 apply. $\mathtt{LagrangeBwK}$ reduction achieves regret $\tilde{O}(T/B)\sqrt{mT}$ (Immorlica et al., 2022). $\mathtt{UcbBwK}$ reduction achieves regret $\tilde{O}(m\sqrt{T})(1+\mathtt{OPT}/B)$ via a computationally inefficient algorithm (Sankararaman and Slivkins, 2021).
Multinomial-logit Bandits with Knapsacks. The setup starts like in combinatorial semi-BwK. There is a ground set of $N$ atoms, and a fixed family $\mathcal{F}â 2^{[N]}$ of feasible actions. In each round, each atom $a$ has an outcome $\vec{o}_{t}(a)â[0,1]^{d+1}$ , and the outcome matrix $\left(\,\vec{o}_{t}(a):aâ[N]\,\right)$ is drawn independently from some fixed but unknown distribution. The aggregate outcome is formed in a different way: when a given subset $A_{t}â\mathcal{F}$ is chosen by the algorithm in a given round $t$ , at most one atom $a_{t}â A_{t}$ is chosen stochastically by ânatureâ, and the aggregate outcome is then $\vec{o}_{t}(A_{t}):=\vec{o}_{t}(a)$ ; otherwise, the algorithm skips this round. A common interpretation is dynamic assortment: that the atoms correspond to products, the chosen action $A_{t}â\mathcal{F}$ is the bundle of products offered to the customer; then at most one product from this bundle is actually purchased. As usual, the algorithm continues until some resource (incl. time) is exhausted.
The selection probabilities are defined via the multinomial-logit model. For each atom $a$ there is a hidden number $v_{a}â[0,1]$ , interpreted as the customersâ valuation of the respective product, and
$$
\Pr\left[\,\text{atom $a$ is chosen}\mid A_{t}\,\right]=\begin{cases}\tfrac{v_{a}}{1+\sum_{a^{\prime}\in A_{t}}v_{a^{\prime}}}&\text{if $a\in A_{t}$}\\
0&\text{otherwise}.\end{cases}
$$
The set of possible bundles is $\mathcal{F}=\{\;Aâ[N]:\;\mathbf{W}·\mathtt{bin}(A)â€\vec{b}\;\}$ , for some (known) totally unimodular matrix $\mathbf{W}â\mathbb{R}^{NĂ N}$ and a vector $\vec{b}â\mathbb{R}^{N}$ , where $\mathtt{bin}(A)â\{0,1\}^{N}$ is a binary-vector representation.
Multinomial-logit (MNL) bandits, the special case without resources, was studied in connection with dynamic assortment, e.g., in Caro and Gallien (2007); Sauré and Zeevi (2013); Rusmevichientong et al. (2010); Agrawal et al. (2019).
MNL-BwK was introduced in Cheung and Simchi-Levi (2017) and solved via a computationally inefficient algorithm. Sankararaman and Slivkins (2021) solve this problem via the $\mathtt{UcbBwK}$ reduction (also computationally inefficiently). Aznag et al. (2021) obtains a computationally efficient version of $\mathtt{UcbBwK}$ . These algorithms achieve regret rates similar to (153), with varying dependence on problem parameters.
Bandit convex optimization (BCO) with knapsacks. BCO is a version of multi-armed bandits where the action set is a convex set $\mathcal{X}â\mathbb{R}^{K}$ , and in each round $t$ , there is a concave function $f_{t}:\mathcal{X}â[0,1]$ such that the reward for choosing action $\vec{x}â\mathcal{X}$ in this round is $f_{t}(\vec{x})$ . BCO is a prominent topic in bandits, starting from (Kleinberg, 2004; Flaxman et al., 2005).
We are interested in a common generalization of BCO and $\mathtt{BwK}$ , called BCO with knapsacks. For each round $t$ and each resource $i$ , one has convex functions $g_{t,i}:\mathcal{X}â[0,1]$ , such that the consumption of this resource for choosing action $\vec{x}â\mathcal{X}$ in this round is $g_{t,i}(\vec{x})$ . The tuple of functions $(f_{t};g_{t,1}\,,\ ...\ ,g_{t,d})$ is sampled independently from some fixed distribution (which is not known to the algorithm). $\mathtt{LagrangeBwK}$ reduction in Immorlica et al. (2022) yields a regret bound of the form $\frac{T}{B}\sqrt{T}·\text{poly}(K\log T)$ , building on the recent breakthrough in BCO in Bubeck et al. (2017). The regret bound is simply $O(\nicefrac{{T}}{{B}})$ times the state-of-art regret bound from Bubeck et al. (2017). Cardoso et al. (2018) obtain a similar regret bound for the full feedback version, in a simultaneous and independent work relative to Immorlica et al. (2022).
Experts with knapsacks. In the full-feedback version of $\mathtt{BwK}$ , the entire outcome matrix $\mathbf{M}_{t}$ is revealed after each round $t$ . Essentially, one can achieve regret bound (148) with $K$ replaced by $\log K$ using $\mathtt{UcbBwK}$ algorithm (Algorithm 3) with a slightly modified analysis. $\mathtt{LagrangeBwK}$ reduction achieves regret $O(T/B)·\sqrt{T\log(dKT)}$ if the âprimalâ algorithm $\mathtt{ALG}_{1}$ is $\mathtt{Hedge}$ from Section 27.
59.3 Beyond the worst case
Characterization for $O(\log T)$ regret. Going beyond worst-case regret bounds, it is natural to ask about smaller, instance-dependent regret rates, akin to $O(\log T)$ regret rates for stochastic bandits from Chapter 1. Sankararaman and Slivkins (2021) find that $O(\log T)$ regret rates are possible for $\mathtt{BwK}$ if and only if two conditions hold: there is only one resource other than time (i.e., $d=2$ ), and the best distribution over arms reduces to the best fixed arm (best-arm-optimality). If either condition fails, any algorithm is doomed to $\Omega(\sqrt{T})$ regret in a wide range of problem instances. The precise formulation of this lower bound is somewhat subtle. It starts with any problem instance $\mathcal{I}_{0}$ with three arms, under mild assumptions, such that either $d>2$ or best-arm optimality fails with some margin. Then it constructs two problem instances $\mathcal{I},\mathcal{I}^{\prime}$ which are $\epsilon$ -perturbations of $\mathcal{I}_{0}$ , $\epsilon=O(\nicefrac{{1}}{{\sqrt{T}}})$ , in the sense that expected rewards and resource consumptions of each arm differ by at most $\epsilon$ . The guarantee is that any algorithm suffers regret $\Omega(\sqrt{(}T))$ on either $\mathcal{I}$ or $\mathcal{I}^{\prime}$ . Here both upper and lower bounds are against the fixed-distribution benchmark ( $\mathtt{OPT_{FD}}$ ).
Assuming $d=2$ and best-arm optimality, $O(\log T)$ regret against $\mathtt{OPT_{FD}}$ is achievable with $\mathtt{UcbBwK}$ algorithm (Sankararaman and Slivkins, 2021). In particular, the algorithm does not know in advance whether best-arm-optimality holds, and attains the optimal worst-case regret bound for all instances, best-arm-optimal or not. The instance-dependent parameter in this regret bound generalizes the gap from stochastic bandits (see Remark 1.1), call it reward-gap in the context of $\mathtt{BwK}$ . The definition uses Lagrange functions from Eq. (142):
$$
G_{\mathtt{LAG}}(a):=\mathtt{OPT}_{\mathtt{LP}}-\mathcal{L}(a,\lambda^{*})\qquad\text{\emph{(Lagrangian gap of arm $a$)}}, \tag{156}
$$
where $\lambda^{*}$ is a minimizer dual vector in Eq. (144), and $G_{\mathtt{LAG}}:=\textstyle\min_{a\notâ\{a^{*},\mathtt{null}\}}G_{\mathtt{LAG}}(a)$ . The regret bound scales as $O(KG_{\mathtt{LAG}}^{-1}\,\log T)$ , which is optimal in $G_{\mathtt{LAG}}$ , under a mild additional assumption that the expected consumption of the best arm is not very close to $\nicefrac{{B}}{{T}}$ . Otherwise, regret is $\mathcal{O}(KG_{\mathtt{LAG}}^{-2}\,\log T)$ .
While the $O(\log T)$ regret result is most meaningful as a part of the characterization, it also stands on its own, even though it requires $d=2$ , best-arm-optimality, and a reasonably small number of arms $K$ . Indeed, $\mathtt{BwK}$ problems with $d=2$ and small $K$ capture the three challenges of $\mathtt{BwK}$ from the discussion in Section 55 and, as spelled out in Sankararaman and Slivkins (2021, Appendix A), arise in many motivating applications. Moreover, best-arm-optimality is a typical, non-degenerate case, in some rigorous sense.
Other results on $O(\log T)$ regret. Several other results achieve $O(\log T)$ regret in $\mathtt{BwK}$ , with various assumptions and caveats, cutting across the characterization discussed above.
Wu et al. (2015) assume deterministic resource consumption, whereas all motivating examples of $\mathtt{BwK}$ require consumption to be stochastic, and in fact correlated with rewards (e.g., dynamic pricing consumes supply only if a sale happens). They posit $d=2$ and no other assumptions, whereas âbest-arm optimalityâ is necessary for stochastic resource consumption.
Flajolet and Jaillet (2015) assume âbest-arm-optimalityâ (it is implicit in the definition of their generalization of reward-gap). Their algorithm inputs an instance-dependent parameter which is normally not revealed to the algorithm (namely, an exact value of some continuous-valued function of mean rewards and consumptions). For $d=2$ , regret bounds for their algorithm scale with $c_{\min}$ , minimal expected consumption among arms: as $c_{\min}^{-4}$ for the $O(\log T)$ bound, and as $c_{\min}^{-2}$ for the worst-case bound. Their analysis extents to $d>2$ , with regret $c_{\min}^{-4}\,K^{K}/\mathtt{gap}^{6}$ and without a worst-case regret bound.
Vera et al. (2020) study a contextual version of $\mathtt{BwK}$ with two arms, one of which does nothing. This formulation is well-motivated for contextual $\mathtt{BwK}$ , but meaningless when specialized to $\mathtt{BwK}$ .
Li et al. (2021) do not make any assumptions, but use additional instance-dependent parameters (i.e., other than their generalization of reward-gap). These parameters spike up and yield $\Omega(\sqrt{T})$ regret whenever the $\Omega(\sqrt{T})$ lower bounds from Sankararaman and Slivkins (2021) apply. Their algorithm does not appear to achieve any non-trivial regret bound in the worst case.
Finally, as mentioned before, György et al. (2007); Tran-Thanh et al. (2010, 2012); Ding et al. (2013); Rangi et al. (2019) posit only one constrained resource and $T=â$ .
Simple regret, which tracks algorithmâs performance in a given round, can be small in all but a few rounds. Like in stochastic bandits, simple regret can be at least $\epsilon$ in at most $\tilde{\mathcal{O}}(K/\epsilon^{2})$ rounds, for all $\epsilon>0$ simultaneously. For stochastic bandits, this is implicit in the analysis in Chapter 3.2 and the original analysis of $\mathtt{UCB1}$ algorithm in Auer et al. (2002a). This result is achieved along with the worst-case and logarithmic regret bounds. In fact, this is achieved by $\mathtt{UcbBwK}$ algorithm (Sankararaman and Slivkins, 2021).
Simple regret for $\mathtt{BwK}$ is defined, for a given round $t$ , as $\mathtt{OPT}/T-r(X_{t})$ , where $X_{t}$ is the distribution over arms chosen by the algorithm in this round. The benchmark $\mathtt{OPT}/T$ generalizes the best-arm benchmark from stochastic bandits. If each round corresponds to a user and the reward is this userâs utility, then $\mathtt{OPT}/T$ is the âfair shareâ of the total reward. Thus, with $\mathtt{UcbBwK}$ , all but a few users receive close to their fair share. This holds if $B>\Omega(T)\gg K$ , without any other assumptions.
59.4 Adversarial bandits with knapsacks
In the adversarial version of $\mathtt{BwK}$ , each outcome matrices $\mathbf{M}_{t}$ is chosen by an adversary. Let us focus on the oblivious adversary, so that the entire sequence $\mathbf{M}_{1},\mathbf{M}_{2}\,,\ ...\ ,\mathbf{M}_{T}$ is fixed before round $1$ . All results below are from Immorlica et al. (2022), unless mentioned otherwise. The version with IID outcomes that weâve considered before will be called Stochastic BwK.
Hardness of the problem. Adversarial BwK is a much harder problem compared to the stochastic version. The new challenge is that the algorithm needs to decide how much budget to save for the future, without being able to predict it. An algorithm must compete, during any given time segment $[1,\tau]$ , with a distribution $D_{\tau}$ over arms that maximizes the total reward on this time segment. However, these distributions may be very different for different $\tau$ . For example, one distribution $D_{\tau}$ may exhaust some resources by time $\tau$ , whereas another distribution $D_{\tau^{\prime}}$ , $\tau^{\prime}>\tau$ may save some resources for later.
Due to this hardness, one can only approximate optimal rewards up to a multiplicative factor, whereas sublinear regret is no longer possible. To state this point more concretely, consider the ratio $\mathtt{OPT_{FD}}/\operatornamewithlimits{\mathbb{E}}[\mathtt{REW}]$ , called competitive ratio, where $\mathtt{OPT_{FD}}$ is the fixed-distribution benchmark (as defined in Section 55). A very strong lower bound holds: no algorithm can achieve competitive ratio better than $O(\log T)$ on all problem instances. The lower-bounding construction involves only two arms and only one resource, and forces the algorithm to make a huge commitment without knowing the future.
It is instructive to consider a simple example in which the competitive ratio is at least $\tfrac{5}{4}-o(1)$ for any algorithm. There are two arms and one resource with budget $\nicefrac{{T}}{{2}}$ . Arm $1$ has zero rewards and zero consumption. Arm $2$ has consumption $1$ in each round, and offers reward $\nicefrac{{1}}{{2}}$ in each round of the first half-time ( $\nicefrac{{T}}{{2}}$ rounds). In the second half-time, it offers either reward $1$ in all rounds, or reward $0$ in all rounds. Thus, there are two problem instances that coincide for the first half-time and differ in the second half-time. The algorithm needs to choose how much budget to invest in the first half-time, without knowing what comes in the second. Any choice leads to competitive ratio at least $\nicefrac{{5}}{{4}}$ on one of the two instances.
A more elaborate version of this example, with $\Omega(\nicefrac{{T}}{{B}})$ phases rather than two, proves that competitive ratio can be no better than $\mathtt{OPT_{FD}}/\operatornamewithlimits{\mathbb{E}}[\mathtt{REW}]â„\Omega(\log\nicefrac{{T}}{{B}})$ in the worst case. More precisely, for any $B†T$ and any algorithm, there is a problem instance with budget $B$ and time horizon $T$ such that $\mathtt{OPT_{FD}}/\operatornamewithlimits{\mathbb{E}}[\mathtt{REW}]â„\tfrac{1}{2}\ln{\lceil{\nicefrac{{T}}{{B}}}\rceil}+\zeta-\tilde{O}(1/\sqrt{B})$ , where $\zeta=0.577...$ is the Euler-Masceroni constant.
The best distribution is arguably a good benchmark for this problem. The best-algorithm benchmark is arguably too harsh: essentially, the ratio $\mathtt{OPT}/\operatornamewithlimits{\mathbb{E}}[\mathtt{REW}]$ cannot be better than $\nicefrac{{T}}{{B}}$ in the worst case. Balseiro and Gur (2019) construct this lower bound for dynamic bidding in second-price auctions (see Section 56). Their guarantee is as follows: for any time horizon $T$ , any constants $0<\gamma<\rho<1$ , and any algorithm there is a problem instance with budget $B=\rho T$ such that $\mathtt{OPT}/\operatornamewithlimits{\mathbb{E}}[\mathtt{REW}]â„\gamma-o(T)$ . The construction uses only $K=T/B$ distinct bids. Immorlica et al. (2022) provide a simpler but weaker guarantee with only $K=2$ arms: for any time horizon $T$ , any budget $B<\sqrt{T}$ and any algorithm, there is a problem instance with $\mathtt{OPT}/\operatornamewithlimits{\mathbb{E}}[\mathtt{REW}]â„ T/B^{2}$ . The fixed-arm benchmark $\mathtt{OPT_{FA}}$ can be arbitrarily worse compared to $\mathtt{OPT_{FD}}$ (see Exercise 10.5). Moreover it is uninteresting: $\mathtt{OPT_{FA}}/\operatornamewithlimits{\mathbb{E}}[\mathtt{REW}]â„\Omega(K)$ for some problem instances, matched by a trivial algorithm that chooses one arm uniformly at random and plays it forever.
Algorithmic results. One can achieve a near-optimal competitive ratio,
$$
\displaystyle(\mathtt{OPT_{FD}}-\mathtt{reg})/\operatornamewithlimits{\mathbb{E}}[\mathtt{REW}]\leq O_{d}(\log T), \tag{157}
$$
up to a regret term $\mathtt{reg}=O(1+\tfrac{\mathtt{OPT_{FD}}}{dB})\sqrt{TK\log(Td)}$ . This is achieved using a version of $\mathtt{LagrangeBwK}$ algorithm, with two important differences: the time resource is not included in the outcome matrices, and the $\nicefrac{{T}}{{B}}$ ratio in the Lagrange function (146) is replaced by a parameter $\gammaâ(0,\nicefrac{{T}}{{B}}]$ , sampled at random from some exponential scale. When $\gamma$ is sampled close to $\mathtt{OPT_{FD}}/B$ , the algorithm obtains a constant competitive ratio. On instances with zero resource consumption, this algorithm achieves $\tilde{O}(\sqrt{KT})$ regret, for any choice of parameter $\gamma$ . A completely new analysis of $\mathtt{LagrangeBwK}$ is needed, as the zero-games framework from Chapter 9 is no longer applicable. The initial analysis in Immorlica et al. (2022) obtains (157) with competitive ratio $\tfrac{d+1}{2}\ln T$ . Kesselheim and Singla (2020) refine this analysis to (157) with competitive ratio $O\left(\,\log(d)\,\log(T)\,\right)$ . They also prove that such competitive ratio is optimal up to constant factors.
One can also achieve an $O(d\log T)$ competitive ratio with high probability:
$$
\displaystyle\Pr\left[\,(\mathtt{OPT_{FD}}-\mathtt{reg})/\mathtt{REW}\leq O(d\log T)\,\right]\geq 1-T^{-2}, \tag{158}
$$
with a somewhat larger regret term $\mathtt{reg}$ . This result uses $\mathtt{LagrangeBwK}$ as a subroutine, and its analysis as a key lemma. The algorithm is considerably more involved: instead of guessing the parameter $\gamma$ upfront, the guess is iteratively refined over time.
It remains open, at the time of this writing, whether constant-factor competitive ratio is possible when $B>\Omega(T)$ , whether against $\mathtt{OPT_{FD}}$ or against $\mathtt{OPT}$ . Balseiro and Gur (2019) achieve competitive ratio $\nicefrac{{T}}{{B}}$ for dynamic bidding in second-price auctions, and derive a matching lower bound (see Footnote 44). Their positive result makes some convexity assumptions, and holds (even) against $\mathtt{OPT}$ .
$\mathtt{LagrangeBwK}$ reduction discussed in Section 59.1 applies to adversarial $\mathtt{BwK}$ as well. We immediately obtain extensions to the same settings as before: contextual $\mathtt{BwK}$ , combinatorial semi- $\mathtt{BwK}$ , BCO with knapsacks, and $\mathtt{BwK}$ with full feedback. For each setting, one obtains the competitive ratios in (157) and (158), with some problem-specific regret terms.
Kesselheim and Singla (2020) consider a more general version of the stopping rule: the algorithm stops at time $t$ if $\|(C_{t,1}\,,\ ...\ ,C_{t,d}\|_{p}>B$ , where $pâ„ 1$ and $C_{t,i}$ is the total consumption of resource $i$ at time $t$ . The case $p=â$ corresponds to $\mathtt{BwK}$ . They obtain the same competitive ratio, $O\left(\,\log(d)\,\log(T)\,\right)$ , using a version of $\mathtt{LagrangeBwK}$ with a different âdualâ algorithm and a different analysis.
Problem variants with sublinear regret. Several results achieve sublinear regret, i.e., a regret bound that is sublinear in $T$ , via various simplifications.
Rangi et al. (2019) consider the special case when there is only one constrained resource, including time. They assume a known lower bound $c_{\min}>0$ on realized per-round consumption of each resource, and their regret bound scales as $1/c_{\min}$ . They also achieve $\text{polylog}(T)$ instance-dependent regret for the stochastic version using the same algorithm (matching results from prior work on the stochastic version).
Several papers posit a relaxed benchmark: they only compare to distributions over actions which satisfy the time-averaged resource constraint in every round. Sun et al. (2017) handles $\mathtt{BwK}$ with $d=2$ resources; their results extend to contextual $\mathtt{BwK}$ with policy sets, via a computationally inefficient algorithm. Online convex optimization with constraints (Mahdavi et al., 2012, 2013; Chen et al., 2017; Neely and Yu, 2017; Chen and Giannakis, 2018) assumes that the action set is a convex subset of $\mathbb{R}^{m}$ , $mâ\mathbb{N}$ , and in each round rewards are concave and consumption of each resource is convex (as functions from actions). In all this work, resource constraints only apply at the last round, and more-than-bandit feedback is observed. Full feedback is observed for the resource consumption, and (except in Chen and Giannakis (2018)) the algorithm also observes either full feedback on rewards or the rewards gradient around the chosen action.
59.5 Paradigmaric application: Dynamic pricing with limited supply
In the basic version, the algorithm is a seller with $B$ identical copies of some product, and there are $T$ rounds. In each round $tâ[T]$ , the algorithm chooses some price $p_{t}â[0,1]$ and offers one copy for sale at this price. The outcome is either a sale or no sale; the corresponding outcome vectors are shown in Eq. (138). The customer response is summarized by the probability of making a sale at a given price $p$ , denoted $S(p)$ , which is assumed to be the same in all rounds, and non-increasing in $p$ . In particular, suppose one customer arrives at time $t$ , with private value $v_{t}$ , and buys if and only if $v_{t}â„ p_{t}$ . If $v_{t}$ is drawn independently from some distribution $D$ , then $S(p)=\Pr_{v\sim D}[vâ„ p]$ . Considering the sales probability directly is more general, e.g., it allows for multiple customers to be present at a given round. The function $S(·)$ is the demand curve, a well-known notion in Economics. The problem was introduced in Besbes and Zeevi (2009). The unconstrained case ( $B=T$ ) is discussed in Section 23.4.
The problem can be solved via discretization: choose a finite subset $Pâ[0,1]$ of prices, and run a generic $\mathtt{BwK}$ algorithm with action set $P$ . The generic guarantees for $\mathtt{BwK}$ provide a regret bound against $\mathtt{OPT}(P)$ , the expected total reward of the best all-knowing algorithm restricted to prices in $P$ . One needs to choose $P$ so as to balance the $\mathtt{BwK}$ regret bound (which scales with $\sqrt{|P|}$ ) and the discretization error $\mathtt{OPT}-\mathtt{OPT}(P)$ (or a similar difference in the LP-values, whichever is more convenient). Bounding the discretization error is a new, non-trivial step, separate from the analysis of the $\mathtt{BwK}$ algorithm. With this approach, Badanidiyuru et al. (2013, 2018) achieve regret bound $\tilde{O}(B^{2/3})$ against $\mathtt{OPT}$ . Note that, up to logarithmic factors, this regret bound is driven by $B$ rather than $T$ . This regret rate is optimal for dynamic pricing, for any given $B,T$ : a complimentary $\Omega(B^{2/3})$ lower bound has been proved in Babaioff et al. (2015a), even against the best fixed price. Interestingly, the optimal regret rate is attained using a generic $\mathtt{BwK}$ algorithm: other than the choice of discretization $P$ , the algorithm is not adapted to dynamic pricing.
Earlier work focused on competing with the best fixed price, i.e., $\mathtt{OPT_{FA}}$ . Babaioff et al. (2015a) achieved $\tilde{O}(B^{2/3})$ regret against $\mathtt{OPT_{FA}}$ , along with the lower bound mentioned above. Their algorithm is a simplified version of $\mathtt{UcbBwK}$ : in each round, it chooses a price with a largest UCB on the expected total reward; this algorithm is run on a pre-selected subset of prices. The initial result from Besbes and Zeevi (2009) assumes $B>\Omega(T)$ and achieves regret $\tilde{O}(T^{3/4})$ , using the explore-first technique (see Chapter 1).
Consider the same problem under regular demands, a standard assumption in theoretical economics which states that $R(p)=p· S(p)$ , the expected revenue at price $p$ , is a concave function of $p$ . Then the best fixed price is close to the best algorithm: $\mathtt{OPT_{FA}}â„\mathtt{OPT}-\tilde{O}(\sqrt{B})$ (Yan, 2011). In particular, the $\tilde{O}(B^{2/3})$ regret bound from Babaioff et al. (2015a) carries over to $\mathtt{OPT}$ . Further, Babaioff et al. (2015a) achieve $\tilde{O}(c_{S}·\sqrt{B})$ regret provided that $B/T†c^{\prime}_{S}$ , where $c_{S}$ and $c^{\prime}_{S}>0$ are some positive constants determined by the demand curve $S$ . They also provide a matching $\Omega(c_{S}·\sqrt{T})$ lower bound, even if an $S$ -dependent constant $c_{S}$ is allowed in $\Omega(·)$ . A simultaneous and independent work, Wang et al. (2014) attains a similar upper bound via a different algorithm, under additional assumptions that $B>\Omega(T)$ and the demand curve $S$ is Lipschitz. The initial result in Besbes and Zeevi (2009) achieved $\tilde{O}(T^{2/3})$ regret under the same assumptions. Wang et al. (2014) also proves a $\Omega(\sqrt{T})$ lower bound, but without an $S$ -dependent constant.
Both lower bounds mentioned above, i.e., $\Omega(B^{2/3})$ against $\mathtt{OPT_{FA}}$ and $\Omega(c_{S}·\sqrt{B})$ for regular demands, are proved in Babaioff et al. (2015a) via a reduction to the respective lower bounds from Kleinberg and Leighton (2003) for the unconstrained case ( $B=T$ ). The latter lower bounds encapsulate most of the âheavy liftingâ in the analysis.
Dynamic pricing with $nâ„ 2$ products in the inventory is less understood. As in the single-product case, one can use discretization and run an optimal $\mathtt{BwK}$ algorithm on a pre-selected finite subset $P$ of price vectors. If the demand curve is Lipschitz, one can bound the discretization error, and achieve regret rate on the order of $T^{(n+1)/(n+2)}$ , see Exercise 10.3 (a). However, it is unclear how to bound the discretization error without Lipschitz assumptions. The only known result in this direction is when there are multiple feasible bundles of goods, and in each round the algorithm chooses a bundle and a price. Then the technique from the single-product case applies, and one obtains a regret bound of $\tilde{O}\left(\,n\,B^{2/3}\,(N\ell)^{1/3}\,\right)$ , where $N$ is the number of bundles, each bundle consists of at most $\ell$ items, and prices are in the range $[0,\ell]$ (Badanidiyuru et al., 2013, 2018). Dynamic pricing with $nâ„ 2$ products was first studied in (Besbes and Zeevi, 2012). They provide several algorithms with non-adaptive exploration for the regime when all budgets are $\Omega(T)$ . In particular, they attain regret $\tilde{O}(T^{1-1/(n+3)})$ when demands are Lipschitz (as a function of prices) and expected revenue is concave (as a function of demands).
While this discussion focuses on regret-minimizing formulations of dynamic pricing, Bayesian and parametric formulations versions have a rich literature in Operations Research and Economics (Boer, 2015).
59.6 Rewards vs. costs
$\mathtt{BwK}$ as defined in this chapter does not readily extend to a version with costs rather than rewards. Indeed, it does not make sense to stop a cost-minimizing algorithm once it runs out of resources â because sich algorithm would seek high-consumption arms in order to stop early! So, a cost-minimizing version of $\mathtt{BwK}$ must require the algorithm to continue till the time horizon $T$ . Likewise, an algorithm cannot be allowed to skip rounds (otherwise it would just skip all rounds). Consequently, the null arm â which is now an arm with maximal cost and no resource consumption â is not guaranteed to exist. In fact, this is the version of $\mathtt{BwK}$ studied in Sun et al. (2017) and the papers on online convex optimization (discussed in Section 59.4).
60 Exercises and hints
(Assume Stochastic BwK unless specified otherwise.)
**Exercise 10.1 (Explore-first algorithm forđ±đ đș\mathtt{BwK})**
*Fix time horizon $T$ and budget $B$ . Consider an algorithm $\mathtt{ALG}$ which explores uniformly at random for the first $N$ steps, where $N$ is fixed in advance, then chooses some distribution $D$ over arms and draws independently from this distribution in each subsequent rounds. - Assume $B<\sqrt{T}$ . Prove that there exists a problem instance on which $\mathtt{ALG}$ suffers linear regret:
$$
\mathtt{OPT}-\operatornamewithlimits{\mathbb{E}}[\mathtt{REW}]>\Omega(T).
$$
Hint: Posit one resource other than time, and three arms:
- the bad arm, with deterministic reward $0$ and consumption $1$ ;
- the good arm, with deterministic reward $1$ and expected consumption $\tfrac{B}{T}$ ;
- the decoy arm, with deterministic reward $1$ and expected consumption $2\tfrac{B}{T}$ .
Use the following fact: given two coins with expectations $\tfrac{B}{T}$ and $\tfrac{B}{T}+c/\sqrt{N}$ , for a sufficiently low absolute constant $c$ , after only $N$ tosses of each coin, for any algorithm it is a constant-probability event that this algorithm cannot tell one coin from another.
- Assume $B>\Omega(T)$ . Choose $N$ and $D$ so that $\mathtt{ALG}$ achieves regret $\mathtt{OPT}-\operatornamewithlimits{\mathbb{E}}[\mathtt{REW}]<\tilde{O}(T^{2/3})$ .
Hint: Choose $D$ as a solution to the âoptimisticâ linear program (150), with rescaled budget $B^{\prime}=B(1-\sqrt{K/T})$ . Compare $D$ to the value of the original linear program (141) with budget $B^{\prime}$ , and the latter to the value of (141) with budget $B$ .*
**Exercise 10.2 (Best distribution vs. best fixed arm)**
*Recall that $\mathtt{OPT_{FA}}$ and $\mathtt{OPT_{FD}}$ are, resp., the fixed-arm benchmark and the fixed-distribution benchmark, as defined in Section 55. Let $d$ be the number of resources, including time. - Construct an example such that $\mathtt{OPT_{FD}}℠d·\mathtt{OPT_{FA}}-o(\mathtt{OPT_{FA}})$ .
Hint: Extend the $d=2$ example from Section 55.
- Prove that $\mathtt{OPT}†d·\mathtt{OPT_{FA}}.$
Hint: (141) has an optimal solution with support size at most $d$ . Use the pigeonhole principle!*
**Exercise 10.3 (Discretization in dynamic pricing)**
*Consider dynamic pricing with limited supply of $d$ products: actions are price vectors $pâ[0,1]^{d}$ , and $c_{i}(p)â[0,1]$ is the expected per-round amount of product $i$ sold at price vector $p$ . Let $P_{\epsilon}:=[0,1]^{d}\cap\epsilon\,\mathbb{N}^{d}$ be a uniform mesh of prices with step $\epsilonâ(0,1)$ . Let $\mathtt{OPT}(P_{\epsilon})$ and $\mathtt{OPT_{FA}}(P_{\epsilon})$ be the resp. benchmark restricted to the price vectors in $P_{\epsilon}$ . - Assume that $c_{i}(p)$ is Lipschitz in $p$ , for each product $i$ :
$$
|c_{i}(p)-c_{i}(p^{\prime})|\leq L\cdot\|p-p\|_{1},\quad\forall p,p^{\prime}\in[0,1]^{d}.
$$
Prove that the discretization error is $\mathtt{OPT}-\mathtt{OPT}(P_{\epsilon})†O(\epsilon dL)$ . Using an optimal $\mathtt{BwK}$ algorithm with appropriately action set $P_{\epsilon}$ , obtain regret rate $\mathtt{OPT}-\operatornamewithlimits{\mathbb{E}}[\mathtt{REW}]<\tilde{O}(T^{(d+1)/(d+2)})$ .
Hint: To bound the discretization error, use the approach from Exercise 10.1; now the deviations in rewards/consumptions are due to the change in $p$ .
- For the single-product case ( $d=1$ ), consider the fixed-arm benchmark, and prove that the resp. discretization error is $\mathtt{OPT_{FA}}-\mathtt{OPT_{FA}}(P_{\epsilon})†O(\epsilon\,\sqrt{B})$ .
Hint: Consider âapproximate total rewardâ at price $p$ as $V(p)=p·\min(B,\,T· S(p))$ . Prove that the expected total reward for always using price $p$ lies between $V(p)-\tilde{O}(\sqrt{B})$ and $V(p)$ .*
**Exercise 10.4 (đ»đđđđđđđđ±đ đș\mathtt{LagrangeBwK}with zero resource consumption)**
*Consider a special case of $\mathtt{BwK}$ with $dâ„ 2$ resources and zero resource consumption. Prove that $\mathtt{LagrangeBwK}$ achieves regret $\tilde{O}(\sqrt{KT})$ . Hint: Instead of the machinery from Chapter 9, use the regret bound for the primal algorithm, and the fact that there exists an optimal solution for (141) with support size $1$ .*
**Exercise 10.5 (đŸđżđđ”đ°\mathtt{OPT_{FA}}for adversarialđ±đ đș\mathtt{BwK})**
*Consider Adversarial $\mathtt{BwK}$ . Prove that $\mathtt{OPT_{FA}}$ can be arbitrarily worse than $\mathtt{OPT_{FD}}$ . Specifically, fix arbitrary time horizon $T$ , budget $B<T/2$ , and number of arms $K$ , and construct a problem instance with $\mathtt{OPT_{FA}}=0$ and $\mathtt{OPT_{FD}}>\Omega(T)$ . Hint: Make all arms have reward $0$ and consumption $1$ in the first $B$ rounds.*
Chapter 11 Bandits and Agents
In many scenarios, multi-armed bandit algorithms interact with self-interested parties, a.k.a. agents. The algorithm can affects agentsâ incentives, and agentsâ decisions in response to these incentives can influence the algorithmâs objectives. We focus this chapter on a particular scenario, incentivized exploration, motivated by exploration in recommendation systems, and we survey some other scenarios in the literature review.
Prerequisites: Chapter 1; Chapter 2 (results only, just for perspective).
Consider a population of self-interested agents that make decisions under uncertainty. They explore to acquire new information and exploit this information to make good decisions. Collectively they need to balance these two objectives, but their incentives are skewed toward exploitation. This is because exploration is costly, but its benefits are spread over many agents in the future. Thus, we ask, How to incentivize self-interested agents to explore when they prefer to exploit?
Our motivation comes from recommendation systems. Users therein consume information from the previous users, and produce information for the future. For example, a decision to dine in a particular restaurant may be based on the existing reviews, and may lead to some new subjective observations about this restaurant. This new information can be consumed either directly (via a review, photo, tweet, etc.) or indirectly through aggregations, summarizations or recommendations, and can help others make similar choices in similar circumstances in a more informed way. This phenomenon applies very broadly, to the choice of a product or experience, be it a movie, hotel, book, home appliance, or virtually any other consumerâs choice. Similar issues, albeit with higher stakes, arise in health and lifestyle decisions such as adjusting exercise routines or selecting a doctor or a hospital. Collecting, aggregating and presenting usersâ observations is a crucial value proposition of numerous businesses in the modern economy.
When self-interested individuals (agents) engage in the information-revealing decisions discussed above, individual and collective incentives are misaligned. If a social planner were to direct the agents, she would trade off exploration and exploitation so as to maximize the social welfare. However, when the decisions are made by the agents rather than enforced by the planner, each agentâs incentives are typically skewed in favor of exploitation, as (s)he would prefer to benefit from exploration done by others. Therefore, the society as a whole may suffer from insufficient amount of exploration. In particular, if a given alternative appears suboptimal given the information available so far, however sparse and incomplete, then this alternative may remain unexplored forever (even though it may be the best).
Let us consider a simple example in which the agents fail to explore. Suppose there are two actions $aâ\{1,2\}$ with deterministic rewards $\mu_{1},\mu_{2}$ that are initially unknown. Each $\mu_{a}$ is drawn independently from a known Bayesian prior such that $\operatornamewithlimits{\mathbb{E}}[\mu_{1}]>\operatornamewithlimits{\mathbb{E}}[\mu_{2}]$ . Agents arrive sequentially: each agent chooses an action, observes its reward and reveals it to all subsequent agents. Then the first agent chooses action $1$ and reveals $\mu_{1}$ . If $\mu_{1}>\operatornamewithlimits{\mathbb{E}}[\mu_{2}]$ , then all future agents also choose arm $1$ . So, action $2$ never gets chosen. This is very wasteful if the prior assigns a large probability to the event $\{\mu_{2}\gg\mu_{1}>\operatornamewithlimits{\mathbb{E}}[\mu_{2}]\}$ .
Our problem, called incentivized exploration, asks how to incentivize the agents to explore. We consider a principal who cannot control the agents, but can communicate with them, e.g., recommend an action and observe the outcome later on. Such a principal would typically be implemented via a website, either one dedicated to recommendations and feedback collection (e.g., Yelp, Waze), or one that actually provides the product or experience being recommended (e.g., Netflix, Amazon). While the principal would often be a for-profit company, its goal for our purposes would typically be well-aligned with the social welfare.
We posit that the principal creates incentives only via communication, rather monetary incentives such as rebates or discounts. Incentives arise due information asymmetry: the fact that the principal collects observations from the past agents and therefore has more information than any one agent. Accordingly, agents realize that (s)he may benefit from following the principalâs recommendations, even these recommendations sometimes include exploration.
Incentivizing exploration is a non-trivial task even in the simple example described above, and even if there are only two agents. This is Bayesian persuasion, a well-studied problem in theoretical economics. When rewards are noisy and incentives are not an issue, the problem reduces to stochastic bandits, as studied in Chapter 1 . Essentially, incentivized exploration needs to solve both problems simultaneously. We design algorithms which create the desired incentives, and (with some caveats) match the performance of the optimal bandit algorithms.
61 Problem formulation: incentivized exploration
We capture the problem discussed above as a bandit problem with auxiliary constraints that arise due to incentives. The problem formulation has two distinct parts: the âalgorithmicâ part, which is essentially about Bayesian bandits, and the âeconomicâ part, which is about agentsâ knowledge and incentives. Such âtwo-partâ structure is very common in the area of algorithmic economics. Each part individually is very standard, according to the literature on bandits and theoretical economics, respectively. It is their combination that leads to a novel and interesting problem.
An algorithm (henceforth, the principal) interacts with self-interested decision-makers (henceforth, agents) over time. There are $T$ rounds and $K$ possible actions, a.k.a. arms; we use $[T]$ and $[K]$ to denote, resp., the set of all rounds and the set of all actions. In each round $tâ[T]$ , the principal recommends an arm $\mathtt{rec}_{t}â[K]$ . Then an agent arrives, observes the recommendation $\mathtt{rec}_{t}$ , chooses an arm $a_{t}$ , receives a reward $r_{t}â[0,1]$ for this arm, and leaves forever. Rewards come from a known parameterized family $(\mathcal{D}_{x}:\;xâ[0,1])$ of reward distributions such that $\operatornamewithlimits{\mathbb{E}}[\mathcal{D}_{x}]=x$ . Specifically, each time a given arm $a$ is chosen, the reward is realized as an independent draw from $\mathcal{D}_{x}$ with mean reward $x=\mu_{a}$ . The mean reward vector $\muâ[0,1]^{K}$ is drawn from a Bayesian prior $\mathcal{P}$ . Prior $\mathcal{P}$ are known, whereas $\mu$ is not.
Problem protocol: Incentivized exploration
Parameters: $K$ arms, $T$ rounds, common prior $\mathcal{P}$ , reward distributions $(\mathcal{D}_{x}:\;xâ[0,1])$ .
Initialization: the mean rewards vector $\muâ[0,1]^{K}$ is drawn from the prior $\mathcal{P}$ .
In each round $t=1,2,3\,,\ ...\ ,T$ :
- Algorithm chooses its recommended arm $\mathtt{rec}_{t}â[K]$ .
- Agent $t$ arrives, receives recommendation $\mathtt{rec}_{t}$ , and chooses arm $a_{t}â[K]$ .
- (Agentâs) reward $r_{t}â[0,1]$ is realized as an independent draw from $D_{x}$ , where $x=\mu_{a_{t}}$ .
- Action $a_{t}$ and reward $r_{t}$ are observed by the algorithm.
**Remark 11.1**
*We allow correlated priors, i.e., random variables $\mu_{a}:\,aâ[K]$ can be correlated. An important special case is independent priors, when these random variables are mutually independent.*
**Remark 11.2**
*If all agents are guaranteed to comply, i.e., follow the algorithmâs recommendations, then the problem protocol coincides with Bayesian bandits, as defined in Chapter 3.*
What does agent $t$ know before (s)he chooses an action? Like the algorithm, (s)he knows the parameterized reward distribution $(\mathcal{D}_{x})$ and the prior $\mathcal{P}$ , but not the mean reward vector $\mu$ . Moreover, (s)he knows the principalâs recommendation algorithm, the recommendation $\mathtt{rec}_{t}$ , and the round $t$ . However, (s)he does not observe what happened with the previous agents.
**Remark 11.3**
*All agents share the same beliefs about the mean rewards (as expressed by the prior $\mathcal{P}$ ), and these beliefs are correct, in the sense that $\mu$ is actually drawn from $\mathcal{P}$ . While idealized, these two assumptions are very common in theoretical economics.*
For each agent $t$ , we put forward a constraint that compliance is in this agentâs best interest. We condition on the event that a particular arm $a$ is being recommended, and the event that all previous agents have complied. The latter event, denoted $\mathcal{E}_{t-1}=\left\{\,a_{s}=\mathtt{rec}_{s}:\;sâ[t-1]\,\right\}$ , ensures that an agent has well-defined beliefs about the behavior of the previous agents.
**Definition 11.4**
*An algorithm is called Bayesian incentive-compatible (BIC) if for all rounds $t$ we have
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}\left[\,\mu_{a}-\mu_{a^{\prime}}\mid\mathtt{rec}_{t}=a,\,\mathcal{E}_{t-1}\,\right]\geq 0, \tag{159}
$$
where $a,a^{\prime}$ are any two distinct arms such that $\Pr\left[\,\mathtt{rec}_{t}=a,\,\mathcal{E}_{t-1}\,\right]>0$ .*
We are (only) interested in BIC algorithms. We posit that all agents comply with such algorithmâs recommendations. Accordingly, a BIC algorithm is simply a bandit algorithm with an auxiliary BIC constraint.
**Remark 11.5**
*The definition of BIC follows one of the standard paradigms in theoretical economics: identify the desirable behavior (in our case, following algorithmâs recommendations), and require that this behavior maximizes each agentâs expected reward, according to her beliefs. Further, to define the agentsâ beliefs, posit that all uncertainty is realized as a random draw from a Bayesian prior, that the prior and the principalâs algorithm are known to the agents, and that all previous agents follow the desired behavior.*
Algorithmâs objective is to maximize the total reward over all rounds. A standard performance measure is Bayesian regret, i.e., pseudo-regret in expectation over the Bayesian prior. We are also interested in comparing BIC bandit algorithms with optimal bandit algorithms.
Preliminaries. We focus the technical developments on the special case of $K=2$ arms (which captures much of the complexity of the general case). Let $\mu_{a}^{0}=\operatornamewithlimits{\mathbb{E}}[\mu_{a}]$ denote the prior mean reward for arm $a$ . W.l.o.g., $\mu_{1}^{0}â„\mu_{2}^{0}$ , i.e., arm $1$ is (weakly) preferred according to the prior. For a more elementary exposition, let us assume that the realized rewards of each arm can only take finitely many possible values.
Let $\mathcal{S}_{1,n}$ denote an ordered tuple of $n$ independent samples from arm $1$ . (Equivalently, $\mathcal{S}_{1,n}$ comprises the first $n$ samples from arm $1$ .) Let $\mathtt{AVG}_{1,n}$ be the average reward in these $n$ samples.
Throughout this chapter, we use a more advanced notion of conditional expectation given a random variable. Letting $X$ be a real-valued random variable, and let $Y$ be another random variable with an arbitrary (not necessarily real-valued) but finite support $\mathcal{Y}$ . The conditional expectation of $X$ given $Y$ is a itself a random variable, $\operatornamewithlimits{\mathbb{E}}[X\mid Y]:=F(Y)$ , where $F(y)=\operatornamewithlimits{\mathbb{E}}[X\mid Y=y]$ for all $yâ\mathcal{Y}$ . The conditional expectation given an event $E$ can be expressed as $\operatornamewithlimits{\mathbb{E}}[X|E]=\operatornamewithlimits{\mathbb{E}}[X|{\bf 1}_{E}]$ . We are particularly interested in $\operatornamewithlimits{\mathbb{E}}[\,·\mid\mathcal{S}_{1,n}]$ , the posterior mean reward after $n$ samples from arm $1$ .
We will repeatedly use the following fact, a version of the law of iterated expectation.
**Fact 11.6**
*Suppose random variable $Z$ is determined by $Y$ and some other random variable $Z_{0}$ such that $X$ and $Z_{0}$ are independent (think of $Z_{0}$ as algorithmâs random seed). Then $\operatornamewithlimits{\mathbb{E}}[\;\operatornamewithlimits{\mathbb{E}}[X|Y]\mid Z]=\operatornamewithlimits{\mathbb{E}}[X|Z]$ .*
62 How much information to reveal?
How much information should the principal reveal to the agents? Consider two extremes: recommending an arm without providing any supporting information, and revealing the entire history. We argue that the former suffices, whereas the latter does not work.
Recommendations suffice. Let us consider a more general model: in each round $t$ , an algorithm $\mathtt{ALG}$ sends the $t$ -th agent an arbitrary message $\sigma_{t}$ , which includes a recommended arm $\mathtt{rec}_{t}â[K]$ . The message lies in some fixed, but otherwise arbitrary, space of possible messages; to keep exposition elementary, assume that this space is finite. A suitable BIC constraint states that recommendation $\mathtt{rec}_{t}$ is optimal given message $\sigma_{t}$ and compliance of the previous agents. In a formula,
$$
\mathtt{rec}_{t}\in\operatornamewithlimits{argmax}_{a\in[K]}\operatornamewithlimits{\mathbb{E}}\left[\,\mu_{a}\mid\sigma_{t},\;\mathcal{E}_{t-1}\,\right],\qquad\forall t\in[T].
$$
Given an algorithm $\mathtt{ALG}$ as above, consider another algorithm $\mathtt{ALG}^{\prime}$ which only reveals recommendation $\mathtt{rec}_{t}$ in each round $t$ . It is easy to see that $\mathtt{ALG}^{\prime}$ is BIC, as per (159). Indeed, fix round $t$ and arm $a$ such that $\Pr\left[\,\mathtt{rec}_{t}=a,\,\mathcal{E}_{t-1}\,\right]>0$ . Then
$$
\operatornamewithlimits{\mathbb{E}}\left[\,\mu_{a}-\mu_{a^{\prime}}\mid\sigma_{t},\;\mathtt{rec}_{t}=a,\,\mathcal{E}_{t-1}\,\right]\geq 0\qquad\forall a^{\prime}\in[K].
$$
We obtain (159) by integrating out the message $\sigma_{t}$ , i.e., by taking conditional expectation of both sides given $\{\mathtt{rec}_{t}=a,\,\mathcal{E}_{t-1}\}$ ; formally, (159) follows by Fact 11.6.
Thus, it suffices to issue recommendations, without any supporting information. This conclusion, along with the simple argument presented above, is a version of a well-known technique from theoretical economics called Myersonâs direct revelation principle. While surprisingly strong, it relies on several subtle assumptions implicit in our model. We discuss these issues more in Section 66.
Full revelation does not work. Even though recommendations suffice, does the principal need to bother designing and deploying a bandit algorithm? In theoretical terms, does the principal need to explore? An appealing alternative is to reveal the full history, perhaps along with some statistics, and let the agents choose for themselves. Being myopic, the agents would follow the Bayesian-greedy algorithm, a Bayesian version of the âgreedyâ bandit algorithm which always âexploitsâ and never âexploresâ.
Formally, suppose in each round $t$ , the algorithm reveals a message $\sigma_{t}$ which includes the history, $H_{t}=\{(a_{s},r_{s}):\,sâ[t-1]\}$ . Posterior mean rewards are determined by $H_{t}$ :
$$
\operatornamewithlimits{\mathbb{E}}[\mu_{a}\mid\sigma_{t}]=\operatornamewithlimits{\mathbb{E}}[\mu_{a}\mid H_{t}]\quad\text{for all arms $a$},
$$
because the rest of the message can only be a function of $H_{t}$ , the algorithmâs random seed, and possibly other inputs that are irrelevant. Consequently, agent $t$ chooses an arm
$$
\displaystyle a_{t}\in\operatornamewithlimits{argmax}_{a\in[K]}\operatornamewithlimits{\mathbb{E}}\left[\,\mu_{a}\mid H_{t}\,\right]. \tag{160}
$$
Up to tie-breaking, this defines an algorithm, which we call $\mathtt{GREEDY}$ . We make no assumptions on how the ties are broken, and what else is included in algorithmâs messages. In contrast with (159), the expectation in (160) is well-defined without $\mathcal{E}_{t-1}$ or any other assumption about the choices of the previous agents, because these choices are already included in the history $H_{t}$ .
$\mathtt{GREEDY}$ performs terribly on a variety of problem instances, suffering Bayesian regret $\Omega(T)$ . (Recall that bandit algorithms can achieve regret $\tilde{O}(\sqrt{T})$ on all problem instances, as per Chapter 1.) The root cause of this inefficiency is that $\mathtt{GREEDY}$ may never try arm $2$ . For the special case of deterministic rewards, this happens with probability $\Pr[\mu_{1}â€\mu_{2}^{0}]$ , since $\mu_{1}$ is revealed in round $1$ and arm $2$ is never chosen if $\mu_{1}â€\mu_{2}^{0}$ . With a different probability, this result carries over to the general case.
**Theorem 11.7**
*With probability at least $\mu_{1}^{0}-\mu_{2}^{0}$ , $\mathtt{GREEDY}$ never chooses arm $2$ .*
* Proof*
In each round $t$ , the key quantity is $Z_{t}=\operatornamewithlimits{\mathbb{E}}[\mu_{1}-\mu_{2}\mid H_{t}]$ . Indeed, arm $2$ is chosen if and only if $Z_{t}<0$ . Let $\tau$ be the first round when $\mathtt{GREEDY}$ chooses arm $2$ , or $T+1$ if this never happens. We use martingale techniques to prove that
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}[Z_{\tau}]=\mu_{1}^{0}-\mu_{2}^{0}. \tag{161}
$$ We obtain Eq. (161) via a standard application of the optional stopping theorem; it can be skipped by readers who are not familiar with martingales. We observe that $\tau$ is a stopping time relative to the sequence $\mathcal{H}=\left(\,H_{t}:\,tâ[T+1]\,\right)$ , and $\left(\,Z_{t}:tâ[T+1]\,\right)$ is a martingale relative to $\mathcal{H}$ . The latter follows from a general fact that sequence $\operatornamewithlimits{\mathbb{E}}[X\mid H_{t}]$ , $tâ[T+1]$ is a martingale w.r.t. $\mathcal{H}$ for any random variable $X$ with $\operatornamewithlimits{\mathbb{E}}\left[\,|X|\,\right]â$ . It is known as Doob martingale for $X$ . The optional stopping theorem asserts that $\operatornamewithlimits{\mathbb{E}}[Z_{\tau}]=\operatornamewithlimits{\mathbb{E}}[Z_{1}]$ for any martingale $Z_{t}$ and any bounded stopping time $\tau$ . Eq. (161) follows because $\operatornamewithlimits{\mathbb{E}}[Z_{1}]=\mu_{1}^{0}-\mu_{2}^{0}$ . On the other hand, by Bayesâ theorem it holds that
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}[Z_{\tau}]=\Pr[\tau\leq T]\,\operatornamewithlimits{\mathbb{E}}[Z_{\tau}\mid\tau\leq T]+\Pr[\tau>T]\,\operatornamewithlimits{\mathbb{E}}[Z_{\tau}\mid\tau>T] \tag{162}
$$
Recall that $\tau†T$ implies that $\mathtt{GREEDY}$ chooses arm $2$ in round $\tau$ , which in turn implies that $Z_{\tau}†0$ by definition of $\mathtt{GREEDY}$ . It follows that $\operatornamewithlimits{\mathbb{E}}[Z_{\tau}\mid\tau†T]†0$ . Plugging this into Eq. (162), we find that
$$
\mu_{1}^{0}-\mu_{2}^{0}=\operatornamewithlimits{\mathbb{E}}[Z_{\tau}]\leq\Pr[\tau>T].
$$
And $\{\tau>T\}$ is precisely the event that $\mathtt{GREEDY}$ never tries arm 2. â
This is a very general result: it holds for arbitrary priors. Under some mild assumptions, the algorithm never tries arm $2$ when it is in fact the best arm, leading to $\Omega(T)$ Bayesian regret.
**Corollary 11.8**
*Consider independent priors such that $\Pr[\mu_{1}=1]<(\mu_{1}^{0}-\mu_{2}^{0})/2$ . Pick any $\alpha>0$ such that $\Pr[\mu_{1}â„ 1-2\,\alpha]â€(\mu_{1}^{0}-\mu_{2}^{0})/2$ . Then $\mathtt{GREEDY}$ suffers Bayesian regret
$$
\operatornamewithlimits{\mathbb{E}}[R(T)]\geq T\cdot\left(\,\tfrac{\alpha}{2}\;(\mu_{1}^{0}-\mu_{2}^{0})\;\Pr[\mu_{2}>1-\alpha]\,\right).
$$*
* Proof*
Let $\mathcal{E}_{1}$ be the event that $\mu_{1}<1-2\alpha$ and $\mathtt{GREEDY}$ never chooses arm $2$ . By Theorem 11.7 and the definition of $\alpha$ , we have $\Pr[\mathcal{E}_{1}]â„(\mu_{1}^{0}-\mu_{2}^{0})/2$ . Let $\mathcal{E}_{2}$ be the event that $\mu_{2}>1-\alpha$ . Under event $\mathcal{E}_{1}\cap\mathcal{E}_{2}$ , each round contributes $\mu_{2}-\mu_{1}â„\alpha$ to regret, so $\operatornamewithlimits{\mathbb{E}}\left[\,R(T)\mid\mathcal{E}_{1}\cap\mathcal{E}_{2}\,\right]â„\alpha\,T$ . Since event $\mathcal{E}_{1}$ is determined by the draw of $\mu_{1}$ and the realized rewards of arm $1$ , it is independent from $\mathcal{E}_{2}$ . It follows that
| | $\displaystyle\operatornamewithlimits{\mathbb{E}}[R(T)]$ | $\displaystyleâ„\operatornamewithlimits{\mathbb{E}}[R(T)\mid\mathcal{E}_{1}\cap\mathcal{E}_{2}]·\Pr[\mathcal{E}_{1}\cap\mathcal{E}_{2}]$ | |
| --- | --- | --- | --- |
Hereâs a less quantitative but perhaps cleaner implication:
**Corollary 11.9**
*Consider independent priors. Assume that each armâs prior has a positive density, i.e., for each arm $a$ , the prior on $\mu_{a}â[0,1]$ has probability density function that is strictly positive on $[0,1]$ . Then $\mathtt{GREEDY}$ suffers Bayesian regret at least $c_{\mathcal{P}}· T$ , where the constant $c_{\mathcal{P}}>0$ depends only on the prior $\mathcal{P}$ .*
63 Basic technique: hidden exploration
The basic technique to ensure incentive-compatibility is to hide a little exploration in a lot of exploitation. Focus on a single round of a bandit algorithm. Suppose we observe a realization of some random variable $\mathtt{sig}â\Omega_{\mathtt{sig}}$ , called the signal. Think of $\mathtt{sig}$ as the algorithmâs history, but it is instructive to keep presentation abstract. For elementary exposition, we assume that the universe $\Omega_{\mathtt{sig}}$ is finite. Otherwise we require a more advanced notion of conditional expectation. With a given probability $\epsilon>0$ , we recommend an arm what we actually want to choose, as described by the (possibly randomized) target function $a_{\mathtt{trg}}:\Omega_{\mathtt{sig}}â\{1,2\}$ . The basic case is just choosing arm $a_{\mathtt{trg}}=2$ . With the remaining probability we exploit, i.e., choose an arm that maximizes $\operatornamewithlimits{\mathbb{E}}\left[\,\mu_{a}\mid\mathtt{sig}\,\right]$ . Thus, the technique, called $\mathtt{HiddenExploration}$ , is as follows:
Parameters: probability $\epsilon>0$ , function $a_{\mathtt{trg}}:\Omega_{\mathtt{sig}}â\{1,2\}$ .
Input: signal realization $Sâ\Omega_{\mathtt{sig}}$ .
Output: recommended arm $\mathtt{rec}$ .
With probability $\epsilon>0$ ,
// exploration branch
$\mathtt{rec}â a_{\mathtt{trg}}(S)$
else
// exploitation branch
$\mathtt{rec}â\min\left(\,\arg\max_{aâ\{1,2\}}\operatornamewithlimits{\mathbb{E}}\left[\,\mu_{a}\mid\mathtt{sig}=S\,\right]\,\right)$
// tie $\Rightarrow$ choose arm $1$
Algorithm 1 $\mathtt{HiddenExploration}$ with signal $\mathtt{sig}$ .
We are interested in the (single-round) BIC property: for any two distinct arms $a,a^{\prime}$
$$
\displaystyle\Pr[\mathtt{rec}=a]>0\;\;\Rightarrow\;\;\operatornamewithlimits{\mathbb{E}}\left[\;\mu_{a}-\mu_{a^{\prime}}\mid\mathtt{rec}=a\;\right]\geq 0 \tag{163}
$$
We prove that $\mathtt{HiddenExploration}$ satisfies this property when the exploration probability $\epsilon$ is sufficiently small, so that the exploration branch is offset by exploitation. A key quantity here is a random variable which summarizes the meaning of signal $\mathtt{sig}$ :
$$
G:=\operatornamewithlimits{\mathbb{E}}[\mu_{2}-\mu_{1}\mid\mathtt{sig}]\qquad\qquad\text{\emph{(posterior gap)}}.
$$
**Lemma 11.10**
*Algorithm 1 is BIC, for any target function $a_{\mathtt{trg}}$ , as long as $\epsilonâ€\tfrac{1}{3}\,\operatornamewithlimits{\mathbb{E}}\left[G·{\bf 1}_{\left\{\,G>0\,\right\}}\right]$ .*
**Remark 11.11**
*A suitable $\epsilon>0$ exists if and only if $\Pr[G>0]>0$ . Indeed, if $\Pr[G>0]>0$ then $\Pr[G>\delta]=\delta^{\prime}>0$ for some $\delta>0$ , so
| | $\displaystyle\operatornamewithlimits{\mathbb{E}}\left[G·{\bf 1}_{\left\{\,G>0\,\right\}}\right]â„\operatornamewithlimits{\mathbb{E}}\left[G·{\bf 1}_{\left\{\,G>\delta\,\right\}}\right]=\Pr[G>\delta]·\operatornamewithlimits{\mathbb{E}}[G\mid G>\delta]â„\delta·\delta^{\prime}>0.$ | |
| --- | --- | --- |*
The rest of this section proves Lemma 11.10. We start with an easy observation: for any algorithm, it suffices to guarantee the BIC property when arm $2$ is recommended.
**Claim 11.12**
*Assume (163) holds for arm $\mathtt{rec}=2$ . Then it also holds for $\mathtt{rec}=1$ .*
* Proof*
If arm $2$ is never recommended, then the claim holds trivially since $\mu_{1}^{0}â„\mu_{2}^{0}$ . Now, suppose both arms are recommended with some positive probability. Then
| | $\displaystyle 0â„\operatornamewithlimits{\mathbb{E}}[\mu_{2}-\mu_{1}]=\textstyle\sum_{aâ\{1,2\}}\;\operatornamewithlimits{\mathbb{E}}[\mu_{2}-\mu_{1}\mid\mathtt{rec}=a]\,\Pr[\mathtt{rec}=a].$ | |
| --- | --- | --- |
Since $\operatornamewithlimits{\mathbb{E}}[\mu_{2}-\mu_{1}\mid\mathtt{rec}=2]>0$ by the BIC assumption, $\operatornamewithlimits{\mathbb{E}}[\mu_{2}-\mu_{1}\mid\mathtt{rec}=1]<0$ . â
Thus, we need to prove (163) for $\mathtt{rec}=2$ , i.e., that
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}\left[\,\mu_{2}-\mu_{1}\mid\mathtt{rec}=2\,\right]>0. \tag{164}
$$
(We note that $\Pr[\mu_{2}-\mu_{1}]>0$ , e.g., because $\Pr[G>0]>0$ , as per Remark 11.11).
Denote the event $\{\mathtt{rec}=2\}$ with $\mathcal{E}_{2}$ . By Fact 11.6, $\operatornamewithlimits{\mathbb{E}}\left[\,\mu_{2}-\mu_{1}\mid\mathcal{E}_{2}\,\right]=\operatornamewithlimits{\mathbb{E}}[G\mid\mathcal{E}_{2}]$ . This is the only step in the analysis where it is essential that both the exploration and exploitation branches (and therefore event $\mathcal{E}_{2}$ ) are determined by the signal $\mathtt{sig}$ .
We focus on the posterior gap $G$ from here on. More specifically, we work with expressions of the form $F(\mathcal{E}):=\operatornamewithlimits{\mathbb{E}}\left[\,G·{\bf 1}_{\mathcal{E}}\,\right]$ , where $\mathcal{E}$ is some event. Proving Eq. (164) is equivalent to proving that $F(\mathcal{E}_{2})>0$ ; we prove the latter in what follows.
We will use the following fact:
$$
\displaystyle F(\mathcal{E}\cup\mathcal{E}^{\prime})=F(\mathcal{E})+F(\mathcal{E}^{\prime})\quad\text{for any disjoint events $\mathcal{E},\mathcal{E}^{\prime}$}. \tag{165}
$$
Letting $\mathcal{E}_{\mathtt{explore}}$ (resp., $\mathcal{E}_{\mathtt{exploit}}$ ) be the event that the algorithm chooses exploration branch (resp., exploitation branch), we can write
$$
\displaystyle F(\mathcal{E}_{2})=F(\mathcal{E}_{\mathtt{explore}}\text{ and }\mathcal{E}_{2})+F(\mathcal{E}_{\mathtt{exploit}}\text{ and }\mathcal{E}_{2}). \tag{166}
$$
We prove that this expression is non-negative by analyzing the exploration and exploitation branches separately. For the exploitation branch, the events $\{\mathcal{E}_{\mathtt{exploit}}\text{ and }\mathcal{E}_{2}\}$ and $\{\mathcal{E}_{\mathtt{exploit}}\text{ and }G>0\}$ are the same by algorithmâs specification. Therefore,
| | $\displaystyle F(\mathcal{E}_{\mathtt{exploit}}\text{ and }\mathcal{E}_{2})$ | $\displaystyle=F(\mathcal{E}_{\mathtt{exploit}}\text{ and }G>0)$ | |
| --- | --- | --- | --- |
For the exploration branch, recall that $F(\mathcal{E})$ is non-negative for any event $\mathcal{E}$ with $G℠0$ , and non-positive for any event $\mathcal{E}$ with $G†0$ . Therefore,
$$
\displaystyle F(\mathcal{E}_{\mathtt{explore}}\text{ and }\mathcal{E}_{2}) \displaystyle=F(\mathcal{E}_{\mathtt{explore}}\text{ and }\mathcal{E}_{2}\text{ and }G<0)+F(\mathcal{E}_{\mathtt{explore}}\text{ and }\mathcal{E}_{2}\text{ and }G\geq 0) \displaystyle\geq F(\mathcal{E}_{\mathtt{explore}}\text{ and }\mathcal{E}_{2}\text{ and }G<0) \displaystyle=F(\mathcal{E}_{\mathtt{explore}}\text{ and }G<0)-F(\mathcal{E}_{\mathtt{explore}}\text{ and }\neg\mathcal{E}_{2}\text{ and }G<0) \displaystyle\geq F(\mathcal{E}_{\mathtt{explore}}\text{ and }G<0) \displaystyle=\operatornamewithlimits{\mathbb{E}}[G\mid\mathcal{E}_{\mathtt{explore}}\text{ and }G<0]\cdot\Pr[\mathcal{E}_{\mathtt{explore}}\text{ and }G<0] \displaystyle=\operatornamewithlimits{\mathbb{E}}[G\mid G<0]\cdot\Pr[G<0]\cdot\epsilon \displaystyle=\epsilon\cdot F(G<0) \displaystyle\text{\emph{(by defn. of $F$)}}. \tag{165}
$$
Putting this together and plugging into (166), we have
$$
\displaystyle F(\mathcal{E}_{2})\geq\epsilon\cdot F(G<0)+(1-\epsilon)\cdot F(G>0). \tag{167}
$$
Now, applying (165) yet again we see that $F(G<0)+F(G>0)=\operatornamewithlimits{\mathbb{E}}[\mu_{2}-\mu_{1}]$ . Plugging this back into (167) and rearranging, it follows that $F(\mathcal{E}_{2})>0$ whenever
$$
F(G>0)>\epsilon\left(\,2F(G>0)+\operatornamewithlimits{\mathbb{E}}[\mu_{1}-\mu_{2}]\,\right).
$$
In particular, $\epsilon<\tfrac{1}{3}· F(G>0)$ suffices. This completes the proof of Lemma 11.10.
64 Repeated hidden exploration
Let us develop the hidden exploration technique into an algorithm for incentivized exploration. We take an arbitrary bandit algorithm $\mathtt{ALG}$ , and consider a repeated version of $\mathtt{HiddenExploration}$ (called $\mathtt{RepeatedHE}$ ), where the exploration branch executes one call to $\mathtt{ALG}$ . We interpret calls to $\mathtt{ALG}$ as exploration. To get started, we include $N_{0}$ rounds of âinitial explorationâ, where arm $1$ is chosen. The exploitation branch conditions on the history of all previous exploration rounds:
$$
\displaystyle\mathcal{S}_{t}=\left(\,(s,a_{s},r_{s}):\text{all exploration rounds $s<t$}\,\right). \tag{168}
$$
Parameters: $N_{0}â\mathbb{N}$ , exploration probability $\epsilon>0$
In the first $N_{0}$ rounds, recommend arm $1$ .
// initial exploration
In each subsequent round $t$ ,
With probability $\epsilon$
// explore
call $\mathtt{ALG}$ , let $\mathtt{rec}_{t}$ be the chosen arm, feed reward $r_{t}$ back to $\mathtt{ALG}$ .
else
// exploit
$\mathtt{rec}_{t}â\min\left(\,\arg\max_{aâ\{1,2\}}\operatornamewithlimits{\mathbb{E}}[\mu_{a}\mid\mathcal{S}_{t}]\,\right)$ .
// $\mathcal{S}_{t}$ from (168)
Algorithm 2 $\mathtt{RepeatedHE}$ with bandit algorithm $\mathtt{ALG}$ .
**Remark 11.13**
*$\mathtt{RepeatedHE}$ can be seen as a reduction from bandit algorithms to BIC bandit algorithms. The simplest version always chooses arm $2$ in exploration rounds, and (only) provides non-adaptive exploration. For better regret bounds, $\mathtt{ALG}$ needs to perform adaptive exploration, as per Chapter 1.*
Each round $t>N_{0}$ can be interpreted as $\mathtt{HiddenExploration}$ with signal $\mathcal{S}_{t}$ , where the âtarget functionâ executes one round of algorithm $\mathtt{ALG}$ . Note that $\mathtt{rec}_{t}$ is determined by $\mathcal{S}_{t}$ and the random seed of $\mathtt{ALG}$ , as required by the specification of $\mathtt{HiddenExploration}$ . Thus, Lemma 11.10 applies, and yields the following corollary in terms of $G_{t}=\operatornamewithlimits{\mathbb{E}}[\mu_{2}-\mu_{1}\mid\mathcal{S}_{t}]$ , the posterior gap given signal $\mathcal{S}_{t}$ .
**Corollary 11.14**
*$\mathtt{RepeatedHE}$ is BIC if $\epsilon<\tfrac{1}{3}\,\operatornamewithlimits{\mathbb{E}}\left[G_{t}·{\bf 1}_{\left\{\,G_{t}>0\,\right\}}\right]$ for each time $t>N_{0}$ .*
For the final BIC guarantee, we show that it suffices to focus on $t=N_{0}+1$ .
**Theorem 11.15**
*$\mathtt{RepeatedHE}$ with exploration probability $\epsilon>0$ and $N_{0}$ initial samples of arm $1$ is BIC as long as $\epsilon<\tfrac{1}{3}\,\operatornamewithlimits{\mathbb{E}}\left[G·{\bf 1}_{\left\{\,G>0\,\right\}}\right]$ , where $G=G_{N_{0}+1}$ .*
* Proof*
The only remaining piece is the claim that the quantity $\operatornamewithlimits{\mathbb{E}}\left[G_{t}·{\bf 1}_{\left\{\,G_{t}>0\,\right\}}\right]$ does not decrease over time. This claim holds for any sequence of signals $(\mathcal{S}_{1},\mathcal{S}_{2}\,,\ ...\ ,S_{T})$ such that each signal $S_{t}$ is determined by the next signal $S_{t+1}$ . Fix round $t$ . Applying Fact 11.6 twice, we obtain
| | $\displaystyle\operatornamewithlimits{\mathbb{E}}[G_{t}\mid G_{t}>0]=\operatornamewithlimits{\mathbb{E}}[\mu_{2}-\mu_{1}\mid G_{t}>0]=\operatornamewithlimits{\mathbb{E}}[G_{t+1}\mid G_{t}>0].$ | |
| --- | --- | --- |
(The last equality uses the fact that $S_{t+1}$ determines $S_{t}$ .) Then,
| | $\displaystyle\operatornamewithlimits{\mathbb{E}}\left[G_{t}·{\bf 1}_{\left\{\,G_{t}>0\,\right\}}\right]$ | $\displaystyle=\operatornamewithlimits{\mathbb{E}}[G_{t}\mid G_{t}>0]·\Pr[G_{t}>0]$ | |
| --- | --- | --- | --- |
The last inequality holds because $x·{\bf 1}_{\left\{\,·\,\right\}}†x·{\bf 1}_{\left\{\,x>0\,\right\}}$ for any $xâ R$ . â
**Remark 11.16**
*The theorem focuses on the posterior gap $G$ given $N_{0}$ initial samples from arm $1$ . The theorem requires parameters $\epsilon>0$ and $N_{0}$ to satisfy some condition that depends only on the prior. Such parameters exist if and only if $\Pr[G>0]>0$ for some $N_{0}$ (for precisely the same reason as in Remark 11.11). The latter condition is in fact necessary, as we will see in Section 65.*
Performance guarantees for $\mathtt{RepeatedHE}$ completely separated from the BIC guarantee, in terms of results as well as proofs. Essentially, $\mathtt{RepeatedHE}$ learns at least as fast as an appropriately slowed-down version of $\mathtt{ALG}$ . There are several natural ways to formalize this, in line with the standard performance measures for multi-armed bandits. For notation, let $\mathtt{REW}^{\mathtt{ALG}}(n)$ be the total reward of $\mathtt{ALG}$ in the first $n$ rounds of its execution, and let $\mathtt{BR}^{\mathtt{ALG}}(n)$ be the corresponding Bayesian regret.
**Theorem 11.17**
*Consider $\mathtt{RepeatedHE}$ with exploration probability $\epsilon>0$ and $N_{0}$ initial samples. Let $N$ be the number of exploration rounds $t>N_{0}$ . Note that $\operatornamewithlimits{\mathbb{E}}[N]=\epsilon(T-N_{0})$ , and $|N-\operatornamewithlimits{\mathbb{E}}[N]|†O(\sqrt{T\,\log T})$ with high probability. Then: - If $\mathtt{ALG}$ always chooses arm $2$ , $\mathtt{RepeatedHE}$ chooses arm $2$ at least N times.
- The expected reward of $\mathtt{RepeatedHE}$ is at least $\tfrac{1}{\epsilon}\,\operatornamewithlimits{\mathbb{E}}\left[\,\mathtt{REW}^{\mathtt{ALG}}(N)\,\right]$ .
- Bayesian regret of $\mathtt{RepeatedHE}$ is $\mathtt{BR}(T)†N_{0}+\tfrac{1}{\epsilon}\,\operatornamewithlimits{\mathbb{E}}\left[\,\mathtt{BR}^{\mathtt{ALG}}(N)\,\right]$ .*
* Proof Sketch*
Part (a) is obvious. Part (c) trivially follows from part (b). The proof of part (b) invokes Waldâs identify and the fact that the expected reward in âexploitationâ is at least as large as in âexplorationâ for the same round. â
**Remark 11.18**
*We match the Bayesian regret of $\mathtt{ALG}$ up to factors $N_{0},\,\tfrac{1}{\epsilon}$ , which depend only on the prior $\mathcal{P}$ (and not on the time horizon or the realization of the mean rewards). In particular, we can achieve $\tilde{O}(\sqrt{T})$ regret for all problem instances, e.g., using algorithm $\mathtt{UCB1}$ from Chapter 1. If a smaller regret rate $f(T)=o(T)$ is achievable for a given prior using some other algorithm $\mathtt{ALG}$ , we can match it, too. However, the prior-dependent factors can be arbitrarily large, depending on the prior.*
65 A necessary and sufficient assumption on the prior
We need to restrict the prior $\mathcal{P}$ so as to give the algorithm a fighting chance to convince some agents to try arm $2$ . (Recall that $\mu_{1}^{0}â„\mu_{2}^{0}$ .) Otherwise the problem is just hopeless. For example, if $\mu_{1}$ and $\mu_{1}-\mu_{2}$ are independent, then samples from arm $1$ have no bearing on the conditional expectation of $\mu_{1}-\mu_{2}$ , and therefore cannot possibly incentivize any agent to try arm $2$ .
We posit that arm $2$ can appear better after seeing sufficiently many samples of arm $1$ . Formally, we consider the posterior gap given $n$ samples from arm $1$ :
$$
\displaystyle G_{1,n}:=\operatornamewithlimits{\mathbb{E}}[\,\mu_{2}-\mu_{1}\mid\mathcal{S}_{1,n}], \tag{169}
$$
where $\mathcal{S}_{1,n}$ denotes an ordered tuple of $n$ independent samples from arm $1$ . We focus on the property that this random variable can be positive:
$$
\displaystyle\Pr\left[G_{1,n}>0\right]>0\quad\text{for some prior-dependent constant $n=n_{\mathcal{P}}<\infty$}. \tag{170}
$$
For independent priors, this property can be simplified to $\Pr[\mu_{2}^{0}>\mu_{1}]>0$ . Essentially, this is because $G_{1,n}=\mu_{2}^{0}-\operatornamewithlimits{\mathbb{E}}[\mu_{1}\mid\mathcal{S}_{1,n}]$ converges to $\mu_{2}^{0}-\mu_{1}$ as $nââ$ .
Recall that Property (170) is sufficient for $\mathtt{RepeatedHE}$ , as per Remark 11.16. We prove that it is necessary for BIC bandit algorithms.
**Theorem 11.19**
*Suppose ties in Definition 11.4 are always resolved in favor of arm $1$ (i.e., imply $\mathtt{rec}_{t}=1$ ). Absent (170), any BIC algorithm never plays arm $2$ .*
* Proof*
Suppose Property (170) does not hold. Let $\mathtt{ALG}$ be a strongly BIC algorithm. We prove by induction on $t$ that $\mathtt{ALG}$ cannot recommend arm $2$ to agent $t$ . This is trivially true for $t=1$ . Suppose the induction hypothesis is true for some $t$ . Then the decision whether to recommend arm $2$ in round $t+1$ (i.e., whether $a_{t+1}=2$ ) is determined by the first $t$ outcomes of arm $1$ and the algorithmâs random seed. Letting $U=\{a_{t+1}=2\}$ , we have
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}[\mu_{2}-\mu_{1}\mid U] \displaystyle=\operatornamewithlimits{\mathbb{E}}\left[\,\;\operatornamewithlimits{\mathbb{E}}[\mu_{2}-\mu_{1}\mid\mathcal{S}_{1,t}]\;\;\mid U\,\right] \displaystyle=\operatornamewithlimits{\mathbb{E}}[G_{1,t}|U] \displaystyle\leq 0 \displaystyle\text{\emph{(since (\ref{BIC:eq:prop}) does not hold)}}. \tag{170}
$$
The last inequality holds because the negation of (170) implies $\Pr[G_{1,t}†0]=1$ . This contradicts $\mathtt{ALG}$ being BIC, and completes the induction proof. â
66 Literature review and discussion: incentivized exploration
The study of incentivized exploration has been initiated in Kremer, Mansour, and Perry (2014) and Che and Hörner (2018). The model in this chapter was introduced in Kremer et al. (2014), and studied under several names, e.g., âBIC bandit explorationâ in Mansour et al. (2020) and âBayesian Explorationâ in Mansour et al. (2022). All results in this chapter are from Mansour, Slivkins, and Syrgkanis (2020), specialized to $K=2$ , with slightly simplified algorithms and a substantially simplified presentation. While Mansour et al. (2020) used a version of $\mathtt{HiddenExploration}$ as a common technique in several results, we identify it as an explicit âbuilding blockâ with standalone guarantees, and use it as a subroutine in the algorithm and a lemma in the overall analysis. The version in Mansour et al. (2020) runs in phases of fixed duration, which consist of exploitation rounds with a few exploration rounds inserted uniformly at random.
Incentivized exploration is connected to theoretical economics in three different ways. First, it adopts the BIC paradigm, as per Remark 11.5. Second, the game between the principal and a single agent in our model has been studied, under the name Bayesian Persuasion, in a long line of work starting from Kamenica and Gentzkow (2011), see Kamenica (2019) for a survey. This is an idealized model for many real-life scenarios in which a more informed âprincipalâ wishes to persuade the âagentâ to take an action which benefits the principal. A broader theme here is the design of âinformation structuresâ: signals received by players in a game (Bergemann and Morris, 2019). A survey (Slivkins, 2023) elucidates the connection between this work and incentivized exploration. Third, the field of social learning studies self-interested agents that jointly learn over time in a shared environment (Golub and Sadler, 2016). In particular, strategic experimentation studies models similar to incentivized exploration, but without a coordinator (Hörner and Skrzypacz, 2017).
The basic model defined in this chapter was studied, and largely resolved, in (Kremer et al., 2014; Mansour et al., 2020, 2022; Cohen and Mansour, 2019; Sellke and Slivkins, 2022). While very idealized, this model is very rich, leading to a variety of results and algorithms. Results extend to $K>2$ , and come in several âflavorsâ other than Bayesian regret: to wit, optimal policies for deterministic rewards, regret bounds for all realizations of the prior, and (sample complexity of) exploring all arms that can be explored. The basic model has been extended in various ways (Mansour et al., 2020, 2022; Bahar et al., 2016, 2019; Immorlica et al., 2019, 2020; Simchowitz and Slivkins, 2023). Generally, the model can be made more realistic in three broad directions: generalize the exploration problem (in all ways that one can generalize multi-armed bandits), generalize the persuasion problem (in all ways that one can generalize Bayesian persuasion), and relax the standard (yet strong) assumptions about agentsâ behavior.
Several papers start with a similar motivation, but adopt substantially different technical models: time-discounted rewards (Bimpikis et al., 2018); continuous information flow and a continuum of agents (Che and Hörner, 2018); incentivizing exploration using money (Frazier et al., 2014; Chen et al., 2018); incentivizing the agents to âparticipateâ even if they knew as much as the algorithm (Bahar et al., 2020); not expecting the agents to comply with recommendations, and instead treating recommendations as âinstrumental variablesâ in statistics (Kallus, 2018; Ngo et al., 2021).
Similar issues, albeit with much higher stakes, arise in medical decisions: selecting a doctor or a hospital, choosing a drug or a treatment, or deciding whether to participate in a medical trial. An individual can consult information from similar individuals in the past, to the extent that such information is available, and later he can contribute his experience as a review or as an outcome in a medical trial. A detailed discussion of the connection to medical trials can be found in Mansour et al. (2020).
In what follows, we spell out the results on the basic model, and briefly survey the extensions.
Diverse results in the basic model. The special case of deterministic rewards and two arms has been optimally solved in the original paper of Kremer et al. (2014). That is, they design a BIC algorithm which exactly optimizes the expected reward, for a given Bayesian prior, among all BIC algorithms. This result has been extended to $K>2$ arms in Cohen and Mansour (2019), under additional assumptions.
$\mathtt{RepeatedHE}$ comes with no guarantees on pseudo-regret for each realization of the prior. Kremer et al. (2014) and Mansour et al. (2020) provide such guarantees, via different algorithms: Kremer et al. (2014) achieve $\tilde{O}(T^{2/3})$ regret, and Mansour et al. (2020) achieve regret bounds with a near-optimal dependence on $T$ , both in the $\tilde{O}(\sqrt{T})$ worst-case sense and in the $O(\log T)$ instance-dependent sense. Both algorithms suffer from prior-dependent factors similar to those in Remark 11.18.
$\mathtt{RepeatedHE}$ and the optimal pseudo-regret algorithm from Mansour et al. (2020) extend to $K>2$ arms under independent priors. $\mathtt{RepeatedHE}$ also works for correlated priors, under a version of assumption (170); however, it is unclear whether this assumption is necessary. Both algorithms require a warm-start: some pre-determined number of samples from each arm. Regret bounds for both algorithms suffer exponential dependence on $K$ in the worst case. Very recently, Sellke and Slivkins (2022) improved this dependence to $\operatornamewithlimits{poly}(K)$ for Bayesian regret and independent priors (more on this below).
While all these algorithms are heavily tailored to incentivized exploration, Sellke and Slivkins (2022) revisit Thompson Sampling, the Bayesian bandit algorithm from Chapter 3. They prove that Thompson Sampling is BIC for independent priors (and any $K$ ), when initialized with prior $\mathcal{P}$ and a sufficient warm-start. If prior mean rewards are the same for all arms, then Thompson Sampling is BIC even without the warm-start. Recall that Thompson Sampling achieves $\tilde{O}(\sqrt{KT})$ Bayesian regret for any prior (Russo and Van Roy, 2014). It is unclear whether other âorganicâ bandit algorithms such as $\mathtt{UCB1}$ can be proved BIC under similar assumptions.
Call an arm explorable if it can be explored with some positive probability by some BIC algorithm. In general, not all arms are explorable. Mansour et al. (2022) design an algorithm which explores all explorable arms, and achieves regret $O(\log T)$ relative to the best explorable arm (albeit with a very large instance-dependent constant). Interestingly, the set of all explorable arms is not determined in advance: instead, observing a particular realization of one arm may âunlockâ the possibility of exploring another arm. In contrast, for independent priors explorability is completely determined by the armsâ priors, and admits a simple characterization (Sellke and Slivkins, 2022): each arm $a$ is explorable if and only if
$$
\displaystyle\Pr\left[\,\mu_{a^{\prime}}<\mu_{a}^{0}\,\right]>0\quad\text{for all arms $a^{\prime}\neq a$}. \tag{171}
$$
All explorable arms can be explored, e.g., via the $K$ -arms extension of $\mathtt{RepeatedHE}$ mentioned above.
Sample complexity. How many rounds are needed to sample each explorable arm even once? This is arguably the most basic objective in incentivized exploration, call it sample complexity. While Mansour et al. (2020, 2022) give rather crude upper bounds for correlated priors, Sellke and Slivkins (2022) obtain tighter results for independent priors. Without loss of generality, one can assume that all arms are explorable, i.e., focus on the arms which satisfy (171). If all per-arm priors belong to some collection $\mathcal{C}$ , one can cleanly decouple the dependence on the number of arms $K$ and the dependence on $\mathcal{C}$ . We are interested in the $\mathcal{C}$ -optimal sample complexity: optimal sample complexity in the worst case over the choice of per-arm priors from $\mathcal{C}$ . The dependence on $\mathcal{C}$ is driven by the smallest variance $\sigma_{\min}^{2}(\mathcal{C})=âf_{\mathcal{P}â\mathcal{C}}\text{Var}(\mathcal{P})$ . The key issue is whether the dependence on $K$ and $\sigma_{\min}(\mathcal{C})$ is polynomial or exponential; e.g., the sample complexity obtained via an extension of the $\mathtt{RepeatedHE}$ can be exponential in both.
Sellke and Slivkins (2022) provide a new algorithm for sampling each arm. Compared to $\mathtt{RepeatedHE}$ , it inserts a third âbranchâ which combines exploration and exploitation, and allows the exploration probability to increase over time. This algorithm is polynomially optimal in the following sense: there is an upper bound $U$ on its sample complexity and a lower bound $L$ on the sample complexity of any BIC algorithm such that $U<\operatornamewithlimits{poly}\left(\,L/\sigma_{\min}(\mathcal{C})\,\right)$ . This result achieves polynomial dependence on $K$ and $\sigma_{\min}(\mathcal{C})$ whenever such dependence is possible, and allows for several refinements detailed below.
The dependence on $K$ admits a very sharp separation: essentially, it is either linear or at least exponential, depending on the collection $\mathcal{C}$ of feasible per-arm priors. In particular, if $\mathcal{C}$ is finite then one compares
$$
\displaystyle\mathtt{minsupp}(\mathcal{C}):=\min_{\mathcal{P}\in\mathcal{C}}\sup(\text{support}(\mathcal{P}))\quad\text{and}\quad\Phi_{\mathcal{C}}:=\max_{\mathcal{P}\in\mathcal{C}}\operatornamewithlimits{\mathbb{E}}[\mathcal{P}]. \tag{172}
$$
The $\mathcal{C}$ -optimal sample complexity is $O_{\mathcal{C}}(K)$ if $\mathtt{minsupp}(\mathcal{C})>\Phi_{\mathcal{C}}$ , and $\exp\left(\,\Omega_{\mathcal{C}}(K)\,\right)$ if $\mathtt{minsupp}(\mathcal{C})<\Phi_{\mathcal{C}}$ . The former regime is arguably quite typical, e.g., it holds in the realistic scenario when all per-arm priors have full support $[0,1]$ , so that $\mathtt{minsupp}(\mathcal{C})=1>\Phi_{\mathcal{C}}$ .
The $\mathcal{C}$ -optimal sample complexity is exponential in $\sigma_{\min}(\mathcal{C})$ , for two canonical special cases: all per-arm priors are, resp., Beta distributions and truncated Gaussians. For the latter case, all per-arm priors are assumed to be Gaussian with the same variance $\sigma^{2}†1$ , conditioned to lie in $[0,1]$ . For Beta priors, different arms may have different variances. Given a problem instance, the optimal sample complexity is exponential in the second -smallest variance, but only polynomial in the smallest variance. This is important when one arm represents a well-known, default alternative, whereas all other arms are new to the agents.
The price of incentives. What is the penalty in performance incurred for the sake of the BIC property? We broadly refer to such penalties as the price of incentives ( $\mathtt{PoI}$ ). The precise definition is tricky to pin down, as the $\mathtt{PoI}$ can be multiplicative or additive, can be expressed via different performance measures, and may depend on the comparator benchmark. Hereâs one version for concreteness: given a BIC algorithm $\mathcal{A}$ and a bandit algorithm $\mathcal{A}^{*}$ that we wish to compare against, suppose $\mathtt{BR}_{\mathcal{A}}(T)=c_{\mathtt{mult}}·\mathtt{BR}_{\mathcal{A}^{*}}(T)+c_{\mathtt{add}}$ , where $\mathtt{BR}_{\mathcal{A}}(T)$ is Bayesian regret of algorithm $\mathcal{A}$ . Then $c_{\mathtt{mult}}$ , $c_{\mathtt{add}}$ are, resp., multiplicative and additive $\mathtt{PoI}$ .
Let us elucidate the $\mathtt{PoI}$ for independent priors, using the results in Sellke and Slivkins (2022). Since Thompson Sampling is BIC with a warm-start (and, arguably, a reasonable benchmark to compare against), the $\mathtt{PoI}$ is only additive, arising due to collecting data for the warm-start. The $\mathtt{PoI}$ is upper-bounded by the sample complexity of collecting this data. The sufficient number of data points per arm, denote it $N$ , is $N=O(K)$ under very mild assumptions, and even $N=O(\log K)$ for Beta priors with bounded variance. We retain all polynomial sample complexity results described above, in terms of $K$ and $\mathtt{minsupp}(\mathcal{C})$ . In particular, the $\mathtt{PoI}$ is $O_{\mathcal{C}}(K)$ if $\mathtt{minsupp}(\mathcal{C})>\Phi_{\mathcal{C}}$ , in the notation from (172).
Alternatively, the initial data points may be collected exogenously, e.g., purchased at a fixed price per data point (then the $\mathtt{PoI}$ is simply the total payment). The $N=O(\log K)$ scaling is particularly appealing if each arm represents a self-interested party, e.g., a restaurant, which wishes to be advertised on the platform. Then each arm can be asked to pay a small, $O(\log K)$ -sized entry fee to subsidise the initial samples.
Extensions of the basic model. Several extensions generalize the exploration problem, i.e., the problem faced by an algorithm (even) without the BIC constraint. $\mathtt{RepeatedHE}$ allows the algorithm to receive auxiliary feedback after each round, e.g., as in combinatorial semi-bandits. This auxiliary feedback is then included in the signal $\mathcal{S}_{t}$ . Moreover, Mansour et al. (2020) extend $\mathtt{RepeatedHE}$ to contextual bandits, under a suitable assumption on the prior which makes all context-arm pairs explorable. Immorlica et al. (2019) study an extension to contextual bandits without any assumptions, and explore all context-arm pairs that are explorable. Simchowitz and Slivkins (2023) consider incentivized exploration in reinforcement learning.
Other extensions generalize the persuasion problem in incentivized exploration.
- (Not) knowing the prior: While $\mathtt{RepeatedHE}$ requires the full knowledge of the prior in order to perform the Bayesian update, the principal is not likely to have such knowledge in practice. To mitigate this issue, one of the algorithms in Mansour et al. (2020) does not input the prior, and instead only requires its parameters (which are similar to $\epsilon,N_{0}$ in $\mathtt{RepeatedHE}$ ) to be consistent with it. In fact, agents can have different beliefs, as long as they are consistent with the algorithmâs parameters.
- Misaligned incentives: The principalâs incentives can be misaligned with the agentsâ: e.g., a vendor may favor more expensive products, and a hospital running a free medical trial may prefer less expensive treatments. Formally, the principal may receive its own, separate rewards for the chosen actions. $\mathtt{RepeatedHE}$ is oblivious to the principalâs incentives, so $\mathtt{ALG}$ can be a bandits-with-predictions algorithm (see Section 5) that learns the best action for the principal. The algorithm in Mansour et al. (2022) (which explores all explorable actions) can also optimize for the principal.
- Heterogenous agents: Each agent has a type which determines her reward distributions and her prior. Extensions to contextual bandits, as discussed above, correspond to public types (i.e., observed by the principal). Immorlica et al. (2019) also investigate private types, the other standard variant when the types are not observed. Their algorithm offers menus which map types to arms, incentivizes each agent to follow the offered menu, and explores all âexplorableâ menus.
- Multiple agents in each round: Multiple agents may arrive simultaneously and directly affect one another (Mansour et al., 2022). E.g., drivers that choose to follow a particular route at the same time may create congestion, which affects everyone. In each round, the principal chooses a distribution $D$ over joint actions, samples a joint action from $D$ , and recommends it to the agents. The BIC constraint requires $D$ to be the Bayes Correlated Equilibrium (Bergemann and Morris, 2013).
- Beyond âminimal revelationâ: What if the agents observe some aspects of the history, even if the principal does not wish them to? In Bahar et al. (2016), the agents observe recommendations to their friends on a social networks (but not the corresponding rewards). In Bahar et al. (2019), each agent observes the action and the reward of the previous agent. Such additional information skews the agents further towards exploitation, and makes the problem much more challenging. Both papers focus on the case of two arms, and assume, resp., deterministic rewards or one known arm.
All results in Mansour et al. (2022); Immorlica et al. (2019); Simchowitz and Slivkins (2023) follow the perspective of exploring all explorable âpiecesâ. The âpiecesâ being explored range from actions to joint actions to context-arm pairs to menus to policies, depending on a particular extension.
Behavioral assumptions. All results discussed above rely heavily on standard but very idealized assumptions about agentsâ behavior. First, the principal announces his algorithm, the agents know and understand it, and trust the principal to faithfully implement it as announced. In theoretical economics, these assumptions are summarily called the (principalâs) power to commit. Second, the agents either trust the BIC property of the algorithm, or can verify it independently. Third, the agents act rationally, i.e., choose arms that maximize their expected utility (e.g., they donât favor less risky arms, and donât occasionally choose less preferable actions). Fourth, the agents find it acceptable that they are given recommendations without any supporting information, and that they may be singled out for low-probability exploration.
One way forward is to define a particular class of algorithms and a model of agentsâ behavior that is (more) plausible for this class. To this end, Immorlica et al. (2020) consider algorithms which reveal some of the history to each agent, and allow a flexible model of greedy-like response. To justify such response, the sub-history revealed to each agent $t$ consists of all rounds that precede $t$ in some fixed and pre-determined partial order. Consequently, each agent observes the history of all agents that could possibly affect her. Put differently, each agent only interacts with a full-revelation algorithm, and the behavioral model does not need to specify how the agents interact with any algorithms that actually explore. Immorlica et al. (2020) design an algorithm in this framework which matches the state-of-art regret bounds.
The greedy algorithm. Theorem 11.7 on the Bayesian-greedy algorithm and its corollaries are from Banihashem et al. (2023). Banihashem et al. (2023) attribute Theorem 11.7 to Sellke (2019). A similar result holds for $K>2$ arms, albeit with a somewhat more complex formulation. While it has been understood for decades that exploitation-only bandit algorithms fail badly for some special cases, Theorem 11.7 is the first non-trivial general result for stochastic rewards that we are aware of. Characterizing the learning performance of Bayesian-greedy more precisely is an open question, even for $K=2$ arms and independent priors, and especially if $\operatornamewithlimits{\mathbb{E}}[\mu_{1}]$ is close to $\operatornamewithlimits{\mathbb{E}}[\mu_{2}]$ . This concerns both the probability of never choosing arm $2$ and Bayesian regret. The latter could be a more complex issue, because Bayesian regret can be accumulated even when arm $2$ is chosen.
The frequentist version of the greedy algorithm replaces posterior mean with empirical mean: in each round, it chooses an arm with a largest empirical mean reward. Initially, each arm is tried $N_{0}$ times, for some small constant $N_{0}$ (warm-up). Focusing on $K=2$ arms, we have a similar learning failure like in Theorem 11.7: the good arm is never chosen again. A trivial argument yields failure probability $e^{-\Omega(N_{0})}$ : consider the event when the good arm receives $0$ reward in all warm-up rounds, and the bad arm receives a non-zero reward in some warm-up round. However, this trivial guarantee is rather weak because of the exponential dependence on $N_{0}$ . A similar but exponentially stronger guarantee is proved in Banihashem et al. (2023), with failure probability on the order of $1/\sqrt{N_{0}}$ . This result is extended to a broader class of agent behaviors (including, e.g., mild optimism and pessimism), and to $K>2$ arms.
Nevertheless, Bayati et al. (2020); Jedor et al. (2021) prove non-trivial (but suboptimal) regret bounds for the frequentist-greedy algorithm on problem instances with a very large number of near-optimal arms. Particularly, for Bayesian bandits with $Kâ„\sqrt{T}$ arms, where the armsâ mean rewards are sampled independently and uniformly.
Several papers find that the greedy algorithm (equivalently, incentivized exploration with full disclosure) performs well in theory under substantial assumptions on heterogeneity of the agents and structure of the rewards. Bastani et al. (2021); Kannan et al. (2018); Raghavan et al. (2023) consider linear contextual bandits, where the contexts come from a sufficiently âdiffuseâ distribution (see Section 47 for a more detailed discussion). Schmit and Riquelme (2018) assume additive agent-specific shift in expected reward of each action, and posit that each agent knows her shift and removes it from the reported reward.
67 Literature review and discussion: other work on bandits and agents
Bandit algorithms interact with self-interested agents in a number of applications. The technical models vary widely, depending on how the agents come into the picture. We partition this literature based on what the agents actually choose: which arm to pull (in incentivized exploration), which bid to report (in an auction), how to respond to an offer (in contract design), or which bandit algorithm to interact with. While this chapter focuses on incentivized exploration, let us now survey the other three lines of work.
67.1 Repeated auctions: agents choose bids
Consider an idealized but fairly generic repeated auction, where in each round the auctioneer allocates one item to one of the auction participants (agents):
Problem protocol: Repeated auction
In each round $t=1,2,3\,,\ ...\ ,T$ :
- Each agent submits a message (bid).
- Auctioneerâs âallocation algorithmâ chooses an agent and allocates one item to this agent.
- The agentâs reward is realized and observed by the algorithm and/or the agent.
- Auctioneer assigns payments.
The auction should incentivize each agent to submit âtruthful bidsâ representing his current knowledge/beliefs about the rewards. The technical definition of truthful bidding differs from one model to another. These details tend to be very lengthy, e.g., compared to a typical setup in multi-armed bandits, and often require background in theoretical economics to appreciate. We keep our exposition at a more basic level. Agentsâ rewards may may not be directly observable by the auctioneer, but they can be derived (in some formal sense) from the auctioneerâs observations and the agentsâ truthful bids. The auctioneer has one of the two standard objectives: social welfare and revenue from the agentsâ payments. Social welfare is the total âutilityâ of the agents and the auctioneer, i.e., since the payments cancel out, the total agentsâ reward. Thus, the allocation algorithm can be implemented as a bandit algorithm, where agents correspond to âarmsâ, and algorithmâs reward is either the agentâs reward or the auctioneerâs revenue, depending on the auctioneerâs objective.
A typical motivation is ad auctions: auctions which allocate advertisement opportunities on the web among the competing advertisers. Hence, one ad opportunity is allocated in each round of the above model, and agents correspond to the advertisers. The auctioneer is a website or an ad platform: an intermediary which connects advertisers and websites with ad opportunities.
The model of dynamic auctions (Bergemann and VĂ€limĂ€ki, 2010; Athey and Segal, 2013; Pavan et al., 2011; Kakade et al., 2013; Bergemann and Said, 2011) posits that the agents do not initially know much about their future rewards. Instead, each agent learns over time by observing his realized rewards when and if he is selected by the algorithm. Further, the auctioneer does not observe the rewards, and instead needs to rely on agentsâ bids. The auctioneer needs to create the right incentives for the agents to stay in the auction and bid their posterior mean rewards. This line of work has been an important development in theoretical economics. It is probably the first appearance of the âbandits with incentivesâ theme in the literature (going by the working papers). Nazerzadeh et al. (2013) consider a similar but technically different model in which the agents are incentivized to report their realized rewards. They create incentives in the âasymptotically approximateâ sense: essentially, truthful bidding is at least as good as any alternative, minus a regret term.
A line of work from algorithmic economics literature (Babaioff et al., 2014; Devanur and Kakade, 2009; Babaioff et al., 2010, 2013, 2015b; Wilkens and Sivan, 2012; Gatti et al., 2012) considers a simpler model, specifically designed to showcase the interaction of bandits and auctions aspects. They consider pay-per-click ad auctions, where advertisers derive value only when users click on their ads, and are charged per click. Click probabilities are largely unknown, which gives rise to a bandit problem. Bids correspond to agentsâ per-click values, which are assumed to be fixed over time. Only the initial bids are considered, all payments are assigned after the last round, and the allocation proceeds over time as a bandit algorithm. Combination of bandit feedback and truthfulness brings about an interesting issue: while it is well-known what the payments must be to ensure truthfulness, the algorithm might not have enough information to compute them. For this reason, Explore-First is essentially the only possible deterministic algorithm Babaioff et al. (2014); Devanur and Kakade (2009). Yet, the required payments can be achieved in expectation by a randomized algorithm. Furthermore, a simple randomized transformation can turn any bandit algorithm into a truthful algorithm, with only a small loss in rewards, as long as the original algorithm satisfies a well-known necessary condition Babaioff et al. (2010, 2013, 2015b).
Another line of work (e.g., Cesa-Bianchi et al., 2013; DudĂk et al., 2017) concerns tuning the auction over time, i.e., adjusting its parameters such as a reserve price. A fresh batch of agents is assumed to arrive in each round (and when and if the same agent arrives more than once, she only cares about the current round). This can be modeled as a contextual problem where âcontextsâ are bids, âarmsâ are the different choices for allocations, and âpoliciesâ (mappings from arms to actions) correspond to the different parameter choices. Alternatively, this can be modeled as a non-contextual problem, where the âarmsâ are the parameter choices.
67.2 Contract design: agents (only) affect rewards
In a variety of settings, the algorithm specifies âcontractsâ for the agents, i.e., rules which map agentsâ performance to outcomes. Agents choose their responses to the offered contracts, and the said responses affect algorithmâs rewards. The nature of the contracts and the responses depends on a particular application.
Most work in this direction posits that the contracts are adjusted over time. In each round, a new agent arrives, the algorithm chooses a âcontractâ, the agent responds, and the reward is revealed. Agentsâ incentives typically impose some structure on the rewards that is useful for the algorithm. In dynamic pricing (Boer, 2015, a survey; see also Section 59.5) and dynamic assortment (e.g., SaurĂ© and Zeevi, 2013; Agrawal et al., 2019) the algorithm offers some items for sale, a contract specifies, resp., the price(s) and the offered assortment of items, and the agents decide whether and which products to buy. (This is a vast and active research area; a more detailed survey is beyond our scope.) In dynamic procurement (e.g., Badanidiyuru et al., 2012, 2018; Singla and Krause, 2013) the algorithm is a buyer and the agents are sellers; alternatively, the algorithm is a contractor on a crowdsourcing market and the agents are workers. The contracts specify the payment(s) for the completed tasks, and the agents decide whether and which tasks to complete. Ho et al. (2016) study a more general model in which the agents are workers who choose their effort level (which is not directly observed by the algorithm), and the contracts specify payment for each quality level of the completed work. One round of this model is a well-known principal-agent model from contract theory (Laffont and Martimort, 2002).
In some other papers, the entire algorithm is a contract, from the agentsâ perspective. In Ghosh and Hummel (2013), the agents choose how much effort to put into writing a review, and then a bandit algorithm chooses among relevant reviews, based on user feedback such as âlikesâ. The effort level affects the ârewardsâ received for the corresponding review. In Braverman et al. (2019) the agents collect rewards directly, unobserved by the algorithm, and pass some of these rewards to the algorithm. The algorithm chooses among agents based on the observed âkick-backsâ, and therefore incentivizes the agents.
A growing line of work studies bandit algorithms for dynamic pricing which can interact with the same agent multiple times. Agentsâ self-interested behavior is typically restricted. One typical assumption is that they are more myopic compared to the algorithm, placing less value on the rewards in the far future (e.g., Amin et al., 2013, 2014). Alternatively, the agents also learn over time, using a low-regret online learning algorithm (e.g., Heidari et al., 2016; Braverman et al., 2018).
67.3 Agents choose between bandit algorithms
Businesses that can deploy bandit algorithms (e.g., web search engines, recommendation systems, or online retailers) often compete with one another. Users can choose which of the competitors to go to, and hence which of the bandit algorithms to interact with. Thus, we have bandit algorithms that compete for users. The said users bring not only utility (such as revenue and/or market share), but also new data to learn from. This leads to a three-way tradeoff between exploration, exploitation, and competition.
Mansour et al. (2018); Aridor et al. (2019, 2020) consider bandit algorithms that optimize a product over time and compete on product quality. They investigate whether competition incentivizes the adoption of better bandit algorithms, and how these incentives depend on the intensity of the competition. In particular, exploration may hurt algorithmâs performance and reputation in the near term, with adverse competitive effects. An algorithm may even enter a âdeath spiralâ, when the short-term reputation cost decreases the number of users for the algorithm to learn from, which degrades the systemâs performance relative to competition and further decreases the market share. These issues are related to the relationship between competition and innovation, a well-studied topic in economics (Schumpeter, 1942; Aghion et al., 2005).
Bergemann and VÀlimÀki (1997, 2000); Keller and Rady (2003) target a very different scenario when the competing firms experiment with prices rather than design alternatives. All three papers consider strategies that respond to competition and analyze Markov-perfect equilibria in the resulting game.
68 Exercises and hints
**Exercise 11.1 (Bayesian-Greedy fails)**
*Prove Corollary 11.8. Hint: Consider the event $\{\mathcal{E}\text{ and }\mu_{1}<1-2\,\alpha\}$ ; this event is independent with $\mu_{2}$ .*
**Exercise 11.2 (performance ofđđđđđđđđđ·đŽ\mathtt{RepeatedHE})**
*Prove Theorem 11.17 (b). Hint: The proof relies on Waldâs identity. Let $t_{i}$ be the $i$ -th round $t>N_{0}$ in which the âexploration branchâ has been chosen. Let $u_{i}$ be the expected reward of $\mathtt{ALG}$ in the $i$ -th round of its execution. Let $X_{i}$ be the expected reward in the time interval $[t_{i},t_{i+1})$ . Use Waldâs identity to prove that $\operatornamewithlimits{\mathbb{E}}[X_{i}]=\tfrac{1}{\epsilon}\,u_{i}$ . Use Waldâs identity again (in a version for non-IID random variables) to prove that $\operatornamewithlimits{\mathbb{E}}[\sum_{i=1}^{N}X_{i}]=\tfrac{1}{\epsilon}\,\operatornamewithlimits{\mathbb{E}}[\sum_{i=1}^{N}u_{i}]$ . Observe that the right-hand side is simply $\tfrac{1}{\epsilon}\,\operatornamewithlimits{\mathbb{E}}[U(N)]$ .*
article
Chapter 12 Concentration inequalities
This appendix provides background on concentration inequalities, sufficient for this book. We use somewhat non-standard formulations that are most convenient for our applications. More background can be found in (McDiarmid, 1998) and (Dubhashi and Panconesi, 2009).
Consider random variables $X_{1},X_{2},...$ . Assume they are mutually independent, but not necessarily identically distributed. Let $\overline{X}_{n}=\tfrac{X_{1}+...+X_{n}}{n}$ be the average of the first $n$ random variables, and let $\mu_{n}=\operatornamewithlimits{\mathbb{E}}[\overline{X}_{n}]$ be its expectation. According to the Strong Law of Large Numbers,
$$
\Pr\left[\,\overline{X}_{n}\to\mu\,\right]=1.
$$
We want to show that $\overline{X}_{n}$ is concentrated around $\mu_{n}$ when $n$ is sufficiently large, in the sense that $|\overline{X}_{n}-\mu_{n}|$ is small with high probability. Thus, we are interested in statements of the following form:
$$
\Pr\left[\,|\overline{X}_{n}-\mu_{n}|\leq\text{``small"}\,\right]\geq 1-\text{``small"}.
$$
Such statements are called âconcentration inequalitiesâ.
Fix $n$ , and focus on the following high-probability event:
$$
\displaystyle\mathcal{E}_{\alpha,\beta}:=\left\{\,|\overline{X}_{n}-\mu_{n}|\leq\sqrt{\alpha\beta\log(T)\,/\,n}\,\right\},\qquad\alpha>0. \tag{173}
$$
The following statement holds, under various assumptions:
$$
\displaystyle\Pr\left[\,\mathcal{E}_{\alpha,\beta}\,\right]\geq 1-2\cdot T^{-2\alpha},\qquad\forall\alpha>0. \tag{174}
$$
Here $T$ is a fixed parameter; think of it as the time horizon in multi-armed bandits. The $\alpha$ controls the failure probability; taking $\alpha=2$ suffices for most applications in this book. The additional parameter $\beta$ depends on the assumptions. The $r_{n}=\sqrt{\frac{\alpha\log T}{n}}$ term in Eq. (173) is called the confidence radius. The interval $[\mu_{n}-r_{n},\,\mu_{n}+r_{n}]$ is called the confidence interval.
**Theorem 12.1 (Hoeffding Inequality)**
*Eq. (174) holds, with $\beta=1$ , if $X_{1}\,,\ ...\ ,X_{n}â[0,1]$ .*
This is the basic result. The special case of Theorem 12.1 with $X_{i}â\{0,1\}$ is known as Chernoff Bounds.
**Theorem 12.2 (Extensions)**
*Eq. (174) holds, for appropriate $\beta$ , in the following cases:
- Bounded intervals: $X_{i}â[a_{i},b_{i}]$ for all $iâ[n]$ , and $\beta=\tfrac{1}{n}\sum_{iâ[n]}(b_{i}-a_{i})^{2}$ .
- Bounded variance: $X_{i}â[0,1]$ and $\mathtt{Variance}(X_{i})â€\beta/8$ for all $iâ[n]$ .
- Gaussians: Each $X_{i}$ , $iâ[n]$ is Gaussian with variance at most $\beta/4$ .*
**Theorem 12.3 (Beyond independence)**
*Consider random variables $X_{1},X_{2},...â[0,1]$ that are not necessarily independent or identically distributed. For each $iâ[n]$ , posit a number $\mu_{i}â[0,1]$ such that
$$
\displaystyle\operatornamewithlimits{\mathbb{E}}\left[X_{i}\mid X_{1}\in J_{1}\,,\ \ldots\ ,X_{i-1}\in J_{i-1}\right]=\mu_{i}, \tag{175}
$$
for any intervals $J_{1}\,,\ ...\ ,J_{i-1}â[0,1]$ . Then Eq. (174) holds, with $\beta=4$ .*
This is a corollary from a well-known Azuma-Hoeffding Inequality. Eq. (175) is essentially the martingale assumption, often used in the literature to extend results on independent random variables.
Chapter 13 Properties of KL-divergence
Let us prove the properties of KL-divergence stated in Theorem 2.4. To recap the main definition, consider a finite sample space $\Omega$ , and let $p,q$ be two probability distributions on $\Omega$ . KL-divergence is defined as:
| | $\displaystyle\mathtt{KL}(p,q)=\sum_{xâ\Omega}p(x)\ln\frac{p(x)}{q(x)}=\mathbb{E}_{p}\left[\ln\frac{p(x)}{q(x)}\right].$ | |
| --- | --- | --- |
**Lemma 13.1 (Gibbsâ Inequality, Theorem2.4(a))**
*$\mathtt{KL}(p,q)â„ 0$ for any two distributions $p,q$ , with equality if and only if $p=q$ .*
* Proof*
Let us define: $f(y)=y\ln(y)$ . $f$ is a convex function under the domain $y>0$ . Now, from the definition of the KL divergence we get:
$$
\displaystyle\mathtt{KL}(p,q) \displaystyle=\sum_{x\in\Omega}q(x)\,\frac{p(x)}{q(x)}\ln\frac{p(x)}{q(x)} \displaystyle=\sum_{x\in\Omega}q(x)f\left(\frac{p(x)}{q(x)}\right) \displaystyle\geq f\left(\sum_{x\in\Omega}q(x)\frac{p(x)}{q(x)}\right) \displaystyle=f\left(\sum_{x\in\Omega}p(x)\right)=f(1)=0, \tag{1}
$$
In the above application of Jensenâs inequality, $f$ is not a linear function, so the equality holds (i.e., $\mathtt{KL}(p,q)=0$ ) if and only if $p=q$ . â
**Lemma 13.2 (Chain rule for product distributions, Theorem2.4(b))**
*Let the sample space be a product $\Omega=\Omega_{1}Ă\Omega_{1}Ă...Ă\Omega_{n}$ . Let $p$ and $q$ be two distributions on $\Omega$ such that $p=p_{1}Ă p_{2}Ă...Ă p_{n}$ and $q=q_{1}Ă q_{2}Ă...Ă q_{n}$ , where $p_{j},q_{j}$ are distributions on $\Omega_{j}$ , for each $jâ[n]$ . Then $\mathtt{KL}(p,q)=\sum_{j=1}^{n}\mathtt{KL}(p_{j},q_{j})$ .*
* Proof*
Let $x=(x_{1},x_{2},...,x_{n})â\Omega$ such that $x_{i}â\Omega_{i}$ for all $i=1\,,\ ...\ ,n$ . Let $h_{i}(x_{i})=\ln\frac{p_{i}(x_{i})}{q_{i}(x_{i})}.$ Then:
| | $\displaystyle\mathtt{KL}(p,q)$ | $\displaystyle=\sum_{xâ\Omega}p(x)\ln\frac{p(x)}{q(x)}$ | |
| --- | --- | --- | --- |
**Lemma 13.3 (Pinskerâs inequality, Theorem2.4(c))**
*Fix event $Aâ\Omega$ . Then
$$
2\left(p(A)-q(A)\right)^{2}\leq\mathtt{KL}(p,q).
$$*
* Proof*
First, we claim that
$$
\displaystyle\sum_{x\in B}p(x)\ln\frac{p(x)}{q(x)}\geq p(B)\ln\frac{p(B)}{q(B)}\qquad\text{for each event $B\subset\Omega$}. \tag{176}
$$
For each $xâ B$ , define $p_{B}(x)=p(x)/p(B)$ and $q_{B}(x)=q(x)/q(B)$ . Then
| | $\displaystyle\sum_{xâ B}p(x)\ln\frac{p(x)}{q(x)}$ | $\displaystyle=p(B)\sum_{xâ B}p_{B}(x)\ln\frac{p(B)· p_{B}(x)}{q(B)· q_{B}(x)}$ | |
| --- | --- | --- | --- | Now that weâve proved (176), let us use it twice: for $B=A$ and for $B=\bar{A}$ , the complement of $A$ :
| | $\displaystyle\sum_{xâ A}p(x)\ln\frac{p(x)}{q(x)}â„ p(A)\ln\frac{p(A)}{q(A)},$ | |
| --- | --- | --- |
Now, let $a=p(A)$ and $b=q(A)$ , and w.l.o.g. assume that $a<b$ . Then:
| | $\displaystyle\mathtt{KL}(p,q)$ | $\displaystyleâ„ a\ln\frac{a}{b}+(1-a)\ln\frac{1-a}{1-b}$ | |
| --- | --- | --- | --- |
**Lemma 13.4 (Random coins, Theorem2.4(d))**
*Fix $\epsilonâ(0,\tfrac{1}{2})$ . Let $\mathtt{RC}_{\epsilon}$ denote a random coin with bias $\tfrac{\epsilon}{2}$ , i.e., a distribution over $\{0,1\}$ with expectation $(1+\epsilon)/2$ . Then $\mathtt{KL}(\mathtt{RC}_{\epsilon},\mathtt{RC}_{0})†2\epsilon^{2}$ and $\mathtt{KL}(\mathtt{RC}_{0},\mathtt{RC}_{\epsilon})â€\epsilon^{2}$ .*
* Proof*
| | $\displaystyle\mathtt{KL}(\mathtt{RC}_{0},\mathtt{RC}_{\epsilon})$ | $\displaystyle=\tfrac{1}{2}\,\ln(\tfrac{1}{1+\epsilon})+\tfrac{1}{2}\,\ln(\tfrac{1}{1-\epsilon})=-\tfrac{1}{2}\,\ln(1-\epsilon^{2})$ | |
| --- | --- | --- | --- |
Now, $\ln(1-\epsilon^{2})<0$ and we can write $\ln\tfrac{1+\epsilon}{1-\epsilon}=\ln\left(1+\tfrac{2\epsilon}{1-\epsilon}\right)â€\tfrac{2\epsilon}{1-\epsilon}$ . Thus, we get:
| | $\displaystyle\mathtt{KL}(\mathtt{RC}_{\epsilon},\mathtt{RC}_{0})<\tfrac{\epsilon}{2}·\tfrac{2\epsilon}{1-\epsilon}=\tfrac{\epsilon^{2}}{1-\epsilon}†2\epsilon^{2}.$ | |
| --- | --- | --- |
References
- Abbasi-Yadkori et al. (2011) Yasin Abbasi-Yadkori, DĂĄvid PĂĄl, and Csaba SzepesvĂĄri. Improved algorithms for linear stochastic bandits. In 25th Advances in Neural Information Processing Systems (NIPS), pages 2312â2320, 2011.
- Abbasi-Yadkori et al. (2012) Yasin Abbasi-Yadkori, DĂĄvid PĂĄl, and Csaba SzepesvĂĄri. Online-to-confidence-set conversions and application to sparse stochastic bandits. In 15th Intl. Conf. on Artificial Intelligence and Statistics (AISTATS), volume 22 of JMLR Proceedings, pages 1â9, 2012.
- Abe et al. (2003) Naoki Abe, Alan W. Biermann, and Philip M. Long. Reinforcement learning with immediate rewards and linear hypotheses. Algorithmica, 37(4):263â293, 2003.
- Abernethy et al. (2008) Jacob Abernethy, Elad Hazan, and Alexander Rakhlin. Competing in the Dark: An Efficient Algorithm for Bandit Linear Optimization. In 21th Conf. on Learning Theory (COLT), pages 263â274, 2008.
- Abernethy and Rakhlin (2009) Jacob D. Abernethy and Alexander Rakhlin. Beating the adaptive bandit with high probability. In 22nd Conf. on Learning Theory (COLT), 2009.
- Abernethy and Wang (2017) Jacob D Abernethy and Jun-Kun Wang. On frank-wolfe and equilibrium computation. In Advances in Neural Information Processing Systems (NIPS), pages 6584â6593, 2017.
- Abraham and Malkhi (2005) Ittai Abraham and Dahlia Malkhi. Name independent routing for growth bounded networks. In 17th ACM Symp. on Parallel Algorithms and Architectures (SPAA), pages 49â55, 2005.
- Agarwal et al. (2012) Alekh Agarwal, Miroslav DudĂk, Satyen Kale, John Langford, and Robert E. Schapire. Contextual bandit learning with predictable rewards. In 15th Intl. Conf. on Artificial Intelligence and Statistics (AISTATS), pages 19â26, 2012.
- Agarwal et al. (2014) Alekh Agarwal, Daniel Hsu, Satyen Kale, John Langford, Lihong Li, and Robert Schapire. Taming the monster: A fast and simple algorithm for contextual bandits. In 31st Intl. Conf. on Machine Learning (ICML), 2014.
- Agarwal et al. (2016) Alekh Agarwal, Sarah Bird, Markus Cozowicz, Miro Dudik, Luong Hoang, John Langford, Lihong Li, Dan Melamed, Gal Oshri, Siddhartha Sen, and Aleksandrs Slivkins. Multiworld testing: A system for experimentation, learning, and decision-making, 2016. A white paper, available at https://github.com/Microsoft/mwt-ds/raw/master/images/MWT-WhitePaper.pdf.
- Agarwal et al. (2017a) Alekh Agarwal, Alina Beygelzimer, Miroslav DudĂk, John Langford, and Hanna Wallach. A reductions approach to fair classification. Fairness, Accountability, and Transparency in Machine Learning (FATML), 2017a.
- Agarwal et al. (2017b) Alekh Agarwal, Sarah Bird, Markus Cozowicz, Luong Hoang, John Langford, Stephen Lee, Jiaji Li, Dan Melamed, Gal Oshri, Oswaldo Ribas, Siddhartha Sen, and Alex Slivkins. Making contextual decisions with low technical debt, 2017b. Techical report at arxiv.org/abs/1606.03966.
- Agarwal et al. (2017c) Alekh Agarwal, Haipeng Luo, Behnam Neyshabur, and Robert E. Schapire. Corralling a band of bandit algorithms. In 30th Conf. on Learning Theory (COLT), pages 12â38, 2017c.
- Agarwal et al. (2020) Alekh Agarwal, Nan Jiang, Sham M Kakade, and Wen Sun. Reinforcement learning: Theory and algorithms, 2020. Book draft, circulated since 2019. Available at https://rltheorybook.github.io.
- Aghion et al. (2005) Philippe Aghion, Nicholas Bloom, Richard Blundell, Rachel Griffith, and Peter Howitt. Competition and innovation: An inverted u relationship. Quaterly J. of Economics, 120(2):701â728, 2005.
- Agrawal (1995) Rajeev Agrawal. The continuum-armed bandit problem. SIAM J. Control and Optimization, 33(6):1926â1951, 1995.
- Agrawal and Devanur (2014) Shipra Agrawal and Nikhil R. Devanur. Bandits with concave rewards and convex knapsacks. In 15th ACM Conf. on Economics and Computation (ACM-EC), 2014.
- Agrawal and Devanur (2016) Shipra Agrawal and Nikhil R. Devanur. Linear contextual bandits with knapsacks. In 29th Advances in Neural Information Processing Systems (NIPS), 2016.
- Agrawal and Devanur (2019) Shipra Agrawal and Nikhil R. Devanur. Bandits with global convex constraints and objective. Operations Research, 67(5):1486â1502, 2019. Preliminary version in ACM EC 2014.
- Agrawal and Goyal (2012) Shipra Agrawal and Navin Goyal. Analysis of Thompson Sampling for the multi-armed bandit problem. In 25nd Conf. on Learning Theory (COLT), 2012.
- Agrawal and Goyal (2013) Shipra Agrawal and Navin Goyal. Further optimal regret bounds for thompson sampling. In 16th Intl. Conf. on Artificial Intelligence and Statistics (AISTATS), pages 99â107, 2013.
- Agrawal and Goyal (2017) Shipra Agrawal and Navin Goyal. Near-optimal regret bounds for thompson sampling. J. of the ACM, 64(5):30:1â30:24, 2017. Preliminary version in AISTATS 2013.
- Agrawal et al. (2014) Shipra Agrawal, Zizhuo Wang, and Yinyu Ye. A dynamic near-optimal algorithm for online linear programming. Operations Research, 62(4):876â890, 2014.
- Agrawal et al. (2016) Shipra Agrawal, Nikhil R. Devanur, and Lihong Li. An efficient algorithm for contextual bandits with knapsacks, and an extension to concave objectives. In 29th Conf. on Learning Theory (COLT), 2016.
- Agrawal et al. (2019) Shipra Agrawal, Vashist Avadhanula, Vineet Goyal, and Assaf Zeevi. Mnl-bandit: A dynamic learning approach to assortment selection. Operations Research, 67(5):1453â1485, 2019. Prelinimary version in ACM EC 2016.
- Ailon et al. (2014) Nir Ailon, Zohar Karnin, and Thorsten Joachims. Reducing dueling bandits to cardinal bandits. In Intl. Conf. on Machine Learning (ICML), pages 856â864, 2014.
- Allenberg et al. (2006) Chamy Allenberg, Peter Auer, Låszló Györfi, and György Ottucsåk. Hannan consistency in on-line learning in case of unbounded losses under partial monitoring. In 17th Intl. Conf. on Algorithmic Learning Theory (ALT), 2006.
- Alon et al. (2013) Noga Alon, NicolĂČ Cesa-Bianchi, Claudio Gentile, and Yishay Mansour. From bandits to experts: A tale of domination and independence. In 27th Advances in Neural Information Processing Systems (NIPS), pages 1610â1618, 2013.
- Alon et al. (2015) Noga Alon, NicolĂČ Cesa-Bianchi, Ofer Dekel, and Tomer Koren. Online learning with feedback graphs: Beyond bandits. In 28th Conf. on Learning Theory (COLT), pages 23â35, 2015.
- Amin et al. (2011) Kareem Amin, Michael Kearns, and Umar Syed. Bandits, query learning, and the haystack dimension. In 24th Conf. on Learning Theory (COLT), 2011.
- Amin et al. (2013) Kareem Amin, Afshin Rostamizadeh, and Umar Syed. Learning prices for repeated auctions with strategic buyers. In 26th Advances in Neural Information Processing Systems (NIPS), pages 1169â1177, 2013.
- Amin et al. (2014) Kareem Amin, Afshin Rostamizadeh, and Umar Syed. Repeated contextual auctions with strategic buyers. In 27th Advances in Neural Information Processing Systems (NIPS), pages 622â630, 2014.
- Anandkumar et al. (2011) Animashree Anandkumar, Nithin Michael, Ao Kevin Tang, and Ananthram Swami. Distributed algorithms for learning and cognitive medium access with logarithmic regret. IEEE Journal on Selected Areas in Communications, 29(4):731â745, 2011.
- Antos et al. (2013) AndrĂĄs Antos, GĂĄbor BartĂłk, DĂĄvid PĂĄl, and Csaba SzepesvĂĄri. Toward a classification of finite partial-monitoring games. Theor. Comput. Sci., 473:77â99, 2013.
- Aridor et al. (2019) Guy Aridor, Kevin Liu, Aleksandrs Slivkins, and Steven Wu. The perils of exploration under competition: A computational modeling approach. In 20th ACM Conf. on Economics and Computation (ACM-EC), 2019.
- Aridor et al. (2020) Guy Aridor, Yishay Mansour, Aleksandrs Slivkins, and Steven Wu. Competing bandits: The perils of exploration under competition., 2020. Working paper. Subsumes conference papers in ITCS 2018 and ACM EC 2019. Available at https://arxiv.org/abs/2007.10144.
- Arora et al. (2012) Sanjeev Arora, Elad Hazan, and Satyen Kale. The multiplicative weights update method: a meta-algorithm and applications. Theory of Computing, 8(1):121â164, 2012.
- Athey and Segal (2013) Susan Athey and Ilya Segal. An efficient dynamic mechanism. Econometrica, 81(6):2463â2485, November 2013. A preliminary version has been available as a working paper since 2007.
- Audibert et al. (2009) J.-Y. Audibert, R. Munos, and Cs. SzepesvĂĄri. Exploration-exploitation trade-off using variance estimates in multi-armed bandits. Theoretical Computer Science, 410:1876â1902, 2009.
- Audibert et al. (2010) Jean-Yves Audibert, SĂ©bastien Bubeck, and RĂ©mi Munos. Best arm identification in multi-armed bandits. In 23rd Conf. on Learning Theory (COLT), pages 41â53, 2010.
- Audibert et al. (2014) Jean-Yves Audibert, SĂ©bastien Bubeck, and GĂĄbor Lugosi. Regret in online combinatorial optimization. Mathematics of Operations Research, 39(1):31â45, 2014.
- Audibert and Bubeck (2010) J.Y. Audibert and S. Bubeck. Regret Bounds and Minimax Policies under Partial Monitoring. J. of Machine Learning Research (JMLR), 11:2785â2836, 2010. Preliminary version in COLT 2009.
- Auer (2002) Peter Auer. Using confidence bounds for exploitation-exploration trade-offs. J. of Machine Learning Research (JMLR), 3:397â422, 2002. Preliminary version in 41st IEEE FOCS, 2000.
- Auer and Chiang (2016) Peter Auer and Chao-Kai Chiang. An algorithm with nearly optimal pseudo-regret for both stochastic and adversarial bandits. In 29th Conf. on Learning Theory (COLT), 2016.
- Auer et al. (2002a) Peter Auer, NicolĂČ Cesa-Bianchi, and Paul Fischer. Finite-time analysis of the multiarmed bandit problem. Machine Learning, 47(2-3):235â256, 2002a.
- Auer et al. (2002b) Peter Auer, NicolĂČ Cesa-Bianchi, Yoav Freund, and Robert E. Schapire. The nonstochastic multiarmed bandit problem. SIAM J. Comput., 32(1):48â77, 2002b. Preliminary version in 36th IEEE FOCS, 1995.
- Auer et al. (2007) Peter Auer, Ronald Ortner, and Csaba SzepesvĂĄri. Improved Rates for the Stochastic Continuum-Armed Bandit Problem. In 20th Conf. on Learning Theory (COLT), pages 454â468, 2007.
- Auer et al. (2019) Peter Auer, Pratik Gajane, and Ronald Ortner. Adaptively tracking the best arm with an unknown number of distribution changes. In Conf. on Learning Theory (COLT), 2019.
- Aumann (1974) Robert J. Aumann. Subjectivity and correlation in randomized strategies. J. of Mathematical Economics, 1:67â96, 1974.
- Avner and Mannor (2014) Orly Avner and Shie Mannor. Concurrent bandits and cognitive radio networks. In European Conf. on Machine Learning and Principles and Practice of Knowledge Discovery in Databases (ECML PKDD), pages 66â81, 2014.
- Awerbuch and Kleinberg (2008) Baruch Awerbuch and Robert Kleinberg. Online linear optimization and adaptive routing. J. of Computer and System Sciences, 74(1):97â114, February 2008. Preliminary version in 36th ACM STOC, 2004.
- Awerbuch et al. (2005) Baruch Awerbuch, David Holmer, Herbert Rubens, and Robert D. Kleinberg. Provably competitive adaptive routing. In 24th Conf. of the IEEE Communications Society (INFOCOM), pages 631â641, 2005.
- Azar et al. (2014) Mohammad Gheshlaghi Azar, Alessandro Lazaric, and Emma Brunskill. Online stochastic optimization under correlated bandit feedback. In 31th Intl. Conf. on Machine Learning (ICML), pages 1557â1565, 2014.
- Aznag et al. (2021) Abdellah Aznag, Vineet Goyal, and Noemie Perivier. Mnl-bandit with knapsacks. In 22th ACM Conf. on Economics and Computation (ACM-EC), 2021.
- Babaioff et al. (2010) Moshe Babaioff, Robert Kleinberg, and Aleksandrs Slivkins. Truthful mechanisms with implicit payment computation. In 11th ACM Conf. on Electronic Commerce (ACM-EC), pages 43â52, 2010.
- Babaioff et al. (2013) Moshe Babaioff, Robert Kleinberg, and Aleksandrs Slivkins. Multi-parameter mechanisms with implicit payment computation. In 13th ACM Conf. on Electronic Commerce (ACM-EC), pages 35â52, 2013.
- Babaioff et al. (2014) Moshe Babaioff, Yogeshwer Sharma, and Aleksandrs Slivkins. Characterizing truthful multi-armed bandit mechanisms. SIAM J. on Computing (SICOMP), 43(1):194â230, 2014. Preliminary version in 10th ACM EC, 2009.
- Babaioff et al. (2015a) Moshe Babaioff, Shaddin Dughmi, Robert D. Kleinberg, and Aleksandrs Slivkins. Dynamic pricing with limited supply. ACM Trans. on Economics and Computation, 3(1):4, 2015a. Special issue for 13th ACM EC, 2012.
- Babaioff et al. (2015b) Moshe Babaioff, Robert Kleinberg, and Aleksandrs Slivkins. Truthful mechanisms with implicit payment computation. J. of the ACM, 62(2):10:1â10:37, 2015b. Subsumes conference papers in ACM EC 2010 and ACM EC 2013.
- Badanidiyuru et al. (2012) Ashwinkumar Badanidiyuru, Robert Kleinberg, and Yaron Singer. Learning on a budget: posted price mechanisms for online procurement. In 13th ACM Conf. on Electronic Commerce (ACM-EC), pages 128â145, 2012.
- Badanidiyuru et al. (2013) Ashwinkumar Badanidiyuru, Robert Kleinberg, and Aleksandrs Slivkins. Bandits with knapsacks. In 54th IEEE Symp. on Foundations of Computer Science (FOCS), 2013.
- Badanidiyuru et al. (2014) Ashwinkumar Badanidiyuru, John Langford, and Aleksandrs Slivkins. Resourceful contextual bandits. In 27th Conf. on Learning Theory (COLT), 2014.
- Badanidiyuru et al. (2018) Ashwinkumar Badanidiyuru, Robert Kleinberg, and Aleksandrs Slivkins. Bandits with knapsacks. J. of the ACM, 65(3):13:1â13:55, 2018. Preliminary version in FOCS 2013.
- Bahar et al. (2016) Gal Bahar, Rann Smorodinsky, and Moshe Tennenholtz. Economic recommendation systems. In 16th ACM Conf. on Electronic Commerce (ACM-EC), page 757, 2016.
- Bahar et al. (2019) Gal Bahar, Rann Smorodinsky, and Moshe Tennenholtz. Social learning and the innkeeperâs challenge. In ACM Conf. on Economics and Computation (ACM-EC), pages 153â170, 2019.
- Bahar et al. (2020) Gal Bahar, Omer Ben-Porat, Kevin Leyton-Brown, and Moshe Tennenholtz. Fiduciary bandits. In 37th Intl. Conf. on Machine Learning (ICML), pages 518â527, 2020.
- Bailey and Piliouras (2018) James P. Bailey and Georgios Piliouras. Multiplicative weights update in zero-sum games. In ACM Conf. on Economics and Computation (ACM-EC), pages 321â338, 2018.
- Balseiro and Gur (2019) Santiago R. Balseiro and Yonatan Gur. Learning in repeated auctions with budgets: Regret minimization and equilibrium. Manag. Sci., 65(9):3952â3968, 2019. Preliminary version in ACM EC 2017.
- Banihashem et al. (2023) Kiarash Banihashem, MohammadTaghi Hajiaghayi, Suho Shin, and Aleksandrs Slivkins. Bandit social learning: Exploration under myopic behavior. In 37th Advances in Neural Information Processing Systems (NeurIPS), 2023.
- Bartlett et al. (2008) Peter L. Bartlett, Varsha Dani, Thomas Hayes, Sham Kakade, Alexander Rakhlin, and Ambuj Tewari. High-probability regret bounds for bandit online linear optimization. In 21th Conf. on Learning Theory (COLT), 2008.
- BartĂłk et al. (2014) GĂĄbor BartĂłk, Dean P. Foster, DĂĄvid PĂĄl, Alexander Rakhlin, and Csaba SzepesvĂĄri. Partial monitoring - classification, regret bounds, and algorithms. Math. Oper. Res., 39(4):967â997, 2014.
- Bastani et al. (2021) Hamsa Bastani, Mohsen Bayati, and Khashayar Khosravi. Mostly exploration-free algorithms for contextual bandits. Management Science, 67(3):1329â1349, 2021. Working paper available on arxiv.org since 2017.
- Bayati et al. (2020) Mohsen Bayati, Nima Hamidi, Ramesh Johari, and Khashayar Khosravi. Unreasonable effectiveness of greedy algorithms in multi-armed bandit with many arms. In 33rd Advances in Neural Information Processing Systems (NeurIPS), 2020.
- Bergemann and Morris (2013) Dirk Bergemann and Stephen Morris. Robust predictions in games with incomplete information. Econometrica, 81(4):1251â1308, 2013.
- Bergemann and Morris (2019) Dirk Bergemann and Stephen Morris. Information design: A unified perspective. Journal of Economic Literature, 57(1):44â95, March 2019.
- Bergemann and Said (2011) Dirk Bergemann and Maher Said. Dynamic auctions: A survey. In Wiley Encyclopedia of Operations Research and Management Science. John Wiley & Sons, 2011.
- Bergemann and VĂ€limĂ€ki (1997) Dirk Bergemann and Juuso VĂ€limĂ€ki. Market diffusion with two-sided learning. The RAND Journal of Economics, pages 773â795, 1997.
- Bergemann and VĂ€limĂ€ki (2000) Dirk Bergemann and Juuso VĂ€limĂ€ki. Experimentation in markets. The Review of Economic Studies, 67(2):213â234, 2000.
- Bergemann and VĂ€limĂ€ki (2010) Dirk Bergemann and Juuso VĂ€limĂ€ki. The dynamic pivot mechanism. Econometrica, 78(2):771â789, 2010. Preliminary versions have been available since 2006.
- Berry and Fristedt (1985) Donald A. Berry and Bert Fristedt. Bandit problems: sequential allocation of experiments. Springer, Heidelberg, Germany, 1985.
- Besbes and Zeevi (2009) Omar Besbes and Assaf Zeevi. Dynamic pricing without knowing the demand function: Risk bounds and near-optimal algorithms. Operations Research, 57(6):1407â1420, 2009.
- Besbes and Zeevi (2012) Omar Besbes and Assaf J. Zeevi. Blind network revenue management. Operations Research, 60(6):1537â1550, 2012.
- Beygelzimer et al. (2011) Alina Beygelzimer, John Langford, Lihong Li, Lev Reyzin, and Robert E. Schapire. Contextual bandit algorithms with supervised learning guarantees. In 14th Intl. Conf. on Artificial Intelligence and Statistics (AISTATS), 2011.
- Bietti et al. (2021) Alberto Bietti, Alekh Agarwal, and John Langford. A contextual bandit bake-off. J. of Machine Learning Research (JMLR), 22:133:1â133:49, 2021.
- Bimpikis et al. (2018) Kostas Bimpikis, Yiangos Papanastasiou, and Nicos Savva. Crowdsourcing exploration. Management Science, 64(4):1727â1746, 2018.
- Blum (1997) Avrim Blum. Empirical support for winnow and weighted-majority based algorithms: Results on a calendar scheduling domain. Machine Learning, 26:5â23, 1997.
- Blum and Mansour (2007) Avrim Blum and Yishay Mansour. From external to internal regret. J. of Machine Learning Research (JMLR), 8(13):1307â1324, 2007. Preliminary version in COLT 2005.
- Blum et al. (2003) Avrim Blum, Vijay Kumar, Atri Rudra, and Felix Wu. Online learning in online auctions. In 14th ACM-SIAM Symp. on Discrete Algorithms (SODA), pages 202â204, 2003.
- Blum et al. (2008) Avrim Blum, MohammadTaghi Hajiaghayi, Katrina Ligett, and Aaron Roth. Regret minimization and the price of total anarchy. In 40th ACM Symp. on Theory of Computing (STOC), pages 373â382, 2008.
- Boer (2015) Arnoud V. Den Boer. Dynamic pricing and learning: Historical origins, current research, and new directions. Surveys in Operations Research and Management Science, 20(1), June 2015.
- Boursier and Perchet (2019) Etienne Boursier and Vianney Perchet. SIC-MMAB: synchronisation involves communication in multiplayer multi-armed bandits. In 32nd Advances in Neural Information Processing Systems (NeurIPS), pages 12048â12057, 2019.
- Braverman et al. (2018) Mark Braverman, Jieming Mao, Jon Schneider, and Matt Weinberg. Selling to a no-regret buyer. In ACM Conf. on Economics and Computation (ACM-EC), pages 523â538, 2018.
- Braverman et al. (2019) Mark Braverman, Jieming Mao, Jon Schneider, and S. Matthew Weinberg. Multi-armed bandit problems with strategic arms. In Conf. on Learning Theory (COLT), pages 383â416, 2019.
- Bresler et al. (2014) Guy Bresler, George H. Chen, and Devavrat Shah. A latent source model for online collaborative filtering. In 27th Advances in Neural Information Processing Systems (NIPS), pages 3347â3355, 2014.
- Bresler et al. (2016) Guy Bresler, Devavrat Shah, and Luis Filipe Voloch. Collaborative filtering with low regret. In The Intl. Conf. on Measurement and Modeling of Computer Systems (SIGMETRICS), pages 207â220, 2016.
- Brown (1949) George W. Brown. Some notes on computation of games solutions. Technical Report P-78, The Rand Corporation, 1949.
- Bubeck (2010) SĂ©bastien Bubeck. Bandits Games and Clustering Foundations. PhD thesis, Univ. Lille 1, 2010.
- Bubeck and Cesa-Bianchi (2012) SĂ©bastien Bubeck and Nicolo Cesa-Bianchi. Regret Analysis of Stochastic and Nonstochastic Multi-armed Bandit Problems. Foundations and Trends in Machine Learning, 5(1):1â122, 2012. Published with Now Publishers (Boston, MA, USA). Also available at https://arxiv.org/abs/1204.5721.
- Bubeck and Liu (2013) SĂ©bastien Bubeck and Che-Yu Liu. Prior-free and prior-dependent regret bounds for thompson sampling. In 26th Advances in Neural Information Processing Systems (NIPS), pages 638â646, 2013.
- Bubeck and Sellke (2020) SĂ©bastien Bubeck and Mark Sellke. First-order bayesian regret analysis of thompson sampling. In 31st Intl. Conf. on Algorithmic Learning Theory (ALT), pages 196â233, 2020.
- Bubeck and Slivkins (2012) SĂ©bastien Bubeck and Aleksandrs Slivkins. The best of both worlds: stochastic and adversarial bandits. In 25th Conf. on Learning Theory (COLT), 2012.
- Bubeck et al. (2011a) SĂ©bastien Bubeck, RĂ©mi Munos, and Gilles Stoltz. Pure Exploration in Multi-Armed Bandit Problems. Theoretical Computer Science, 412(19):1832â1852, 2011a.
- Bubeck et al. (2011b) SĂ©bastien Bubeck, RĂ©mi Munos, Gilles Stoltz, and Csaba Szepesvari. Online Optimization in X-Armed Bandits. J. of Machine Learning Research (JMLR), 12:1587â1627, 2011b. Preliminary version in NIPS 2008.
- Bubeck et al. (2011c) SĂ©bastien Bubeck, Gilles Stoltz, and Jia Yuan Yu. Lipschitz bandits without the lipschitz constant. In 22nd Intl. Conf. on Algorithmic Learning Theory (ALT), pages 144â158, 2011c.
- Bubeck et al. (2015) SĂ©bastien Bubeck, Ofer Dekel, Tomer Koren, and Yuval Peres. Bandit convex optimization: \(\sqrt{T}\) regret in one dimension. In 28th Conf. on Learning Theory (COLT), pages 266â278, 2015.
- Bubeck et al. (2017) SĂ©bastien Bubeck, Yin Tat Lee, and Ronen Eldan. Kernel-based methods for bandit convex optimization. In 49th ACM Symp. on Theory of Computing (STOC), pages 72â85. ACM, 2017.
- Bubeck et al. (2019) SĂ©bastien Bubeck, Yuanzhi Li, Haipeng Luo, and Chen-Yu Wei. Improved path-length regret bounds for bandits. In Conf. on Learning Theory (COLT), 2019.
- Bubeck et al. (2020) SĂ©bastien Bubeck, Yuanzhi Li, Yuval Peres, and Mark Sellke. Non-stochastic multi-player multi-armed bandits: Optimal rate with collision information, sublinear without. In 33rd Conf. on Learning Theory (COLT), pages 961â987, 2020.
- Bull (2015) Adam Bull. Adaptive-treed bandits. Bernoulli J. of Statistics, 21(4):2289â2307, 2015.
- Cardoso et al. (2018) Adrian Rivera Cardoso, He Wang, and Huan Xu. Online saddle point problem with applications to constrained online convex optimization. arXiv preprint arXiv:1806.08301, 2018.
- Caro and Gallien (2007) Felipe Caro and JĂ©rĂ©mie Gallien. Dynamic assortment with demand learning for seasonal consumer goods. Management Science, 53(2):276â292, 2007.
- Carpentier and Locatelli (2016) Alexandra Carpentier and Andrea Locatelli. Tight (lower) bounds for the fixed budget best arm identification bandit problem. In 29th Conf. on Learning Theory (COLT), pages 590â604, 2016.
- Carpentier and Munos (2012) Alexandra Carpentier and RĂ©mi Munos. Bandit theory meets compressed sensing for high dimensional stochastic linear bandit. In 15th Intl. Conf. on Artificial Intelligence and Statistics (AISTATS), volume 22 of JMLR Proceedings, pages 190â198, 2012.
- Cesa-Bianchi and Lugosi (2003) NicolĂČ Cesa-Bianchi and GĂĄbor Lugosi. Potential-based algorithms in on-line prediction and game theory. Machine Learning, 51(3):239â261, 2003.
- Cesa-Bianchi and Lugosi (2006) NicolĂČ Cesa-Bianchi and GĂĄbor Lugosi. Prediction, learning, and games. Cambridge University Press, Cambridge, UK, 2006.
- Cesa-Bianchi and Lugosi (2012) NicolĂČ Cesa-Bianchi and GĂĄbor Lugosi. Combinatorial bandits. J. Comput. Syst. Sci., 78(5):1404â1422, 2012. Preliminary version in COLT 2009.
- Cesa-Bianchi et al. (1997) NicolĂČ Cesa-Bianchi, Yoav Freund, David Haussler, David P. Helmbold, Robert E. Schapire, and Manfred K. Warmuth. How to use expert advice. J. ACM, 44(3):427â485, 1997.
- Cesa-Bianchi et al. (2013) NicolĂł Cesa-Bianchi, Claudio Gentile, and Yishay Mansour. Regret minimization for reserve prices in second-price auctions. In ACM-SIAM Symp. on Discrete Algorithms (SODA), 2013.
- Cesa-Bianchi et al. (2017) NicolĂČ Cesa-Bianchi, Pierre Gaillard, Claudio Gentile, and SĂ©bastien Gerchinovitz. Algorithmic chaining and the role of partial feedback in online nonparametric learning. In 30th Conf. on Learning Theory (COLT), pages 465â481, 2017.
- Chakrabarti et al. (2008) Deepayan Chakrabarti, Ravi Kumar, Filip Radlinski, and Eli Upfal. Mortal multi-armed bandits. In 22nd Advances in Neural Information Processing Systems (NIPS), pages 273â280, 2008.
- Che and Hörner (2018) Yeon-Koo Che and Johannes Hörner. Recommender systems as mechanisms for social learning. Quarterly Journal of Economics, 133(2):871â925, 2018. Working paper since 2013, titled âOptimal design for social learningâ.
- Chen et al. (2018) Bangrui Chen, Peter I. Frazier, and David Kempe. Incentivizing exploration by heterogeneous users. In Conf. on Learning Theory (COLT), pages 798â818, 2018.
- Chen and Giannakis (2018) Tianyi Chen and Georgios B Giannakis. Bandit convex optimization for scalable and dynamic iot management. IEEE Internet of Things Journal, 2018.
- Chen et al. (2017) Tianyi Chen, Qing Ling, and Georgios B Giannakis. An online convex optimization approach to proactive network resource allocation. IEEE Transactions on Signal Processing, 65(24):6350â6364, 2017.
- Chen et al. (2013) Wei Chen, Yajun Wang, and Yang Yuan. Combinatorial multi-armed bandit: General framework and applications. In 20th Intl. Conf. on Machine Learning (ICML), pages 151â159, 2013.
- Chen et al. (2016) Wei Chen, Wei Hu, Fu Li, Jian Li, Yu Liu, and Pinyan Lu. Combinatorial multi-armed bandit with general reward functions. In 29th Advances in Neural Information Processing Systems (NIPS), pages 1651â1659, 2016.
- Chen et al. (2019) Yifang Chen, Chung-Wei Lee, Haipeng Luo, and Chen-Yu Wei. A new algorithm for non-stationary contextual bandits: Efficient, optimal, and parameter-free. In Conf. on Learning Theory (COLT), 2019.
- Cheung and Simchi-Levi (2017) Wang Chi Cheung and David Simchi-Levi. Assortment optimization under unknown multinomial logit choice models, 2017. Technical report, available at http://arxiv.org/abs/1704.00108.
- Cheung and Piliouras (2019) Yun Kuen Cheung and Georgios Piliouras. Vortices instead of equilibria in minmax optimization: Chaos and butterfly effects of online learning in zero-sum games. In Conf. on Learning Theory (COLT), pages 807â834, 2019.
- Chow and Chang (2008) Shein-Chung Chow and Mark Chang. Adaptive design methods in clinical trials â a review. Orphanet Journal of Rare Diseases, 3(11):1750â1172, 2008.
- Christiano et al. (2011) Paul Christiano, Jonathan A. Kelner, Aleksander Madry, Daniel A. Spielman, and Shang-Hua Teng. Electrical flows, laplacian systems, and faster approximation of maximum flow in undirected graphs. In 43rd ACM Symp. on Theory of Computing (STOC), pages 273â282. ACM, 2011.
- Chu et al. (2011) Wei Chu, Lihong Li, Lev Reyzin, and Robert E. Schapire. Contextual Bandits with Linear Payoff Functions. In 14th Intl. Conf. on Artificial Intelligence and Statistics (AISTATS), 2011.
- Cohen and Mansour (2019) Lee Cohen and Yishay Mansour. Optimal algorithm for bayesian incentive-compatible exploration. In ACM Conf. on Economics and Computation (ACM-EC), pages 135â151, 2019.
- Combes and ProutiĂšre (2014a) Richard Combes and Alexandre ProutiĂšre. Unimodal bandits without smoothness, 2014a. Working paper, available at http://arxiv.org/abs/1406.7447.
- Combes and ProutiĂšre (2014b) Richard Combes and Alexandre ProutiĂšre. Unimodal bandits: Regret lower bounds and optimal algorithms. In 31st Intl. Conf. on Machine Learning (ICML), pages 521â529, 2014b.
- Combes et al. (2015) Richard Combes, Chong Jiang, and Rayadurgam Srikant. Bandits with budgets: Regret lower bounds and optimal algorithms. ACM SIGMETRICS Performance Evaluation Review, 43(1):245â257, 2015.
- Combes et al. (2017) Richard Combes, Stefan Magureanu, and Alexandre ProutiĂšre. Minimal exploration in structured stochastic bandits. In 30th Advances in Neural Information Processing Systems (NIPS), pages 1763â1771, 2017.
- Cope (2009) Eric W. Cope. Regret and convergence bounds for a class of continuum-armed bandit problems. IEEE Trans. Autom. Control., 54(6):1243â1253, 2009.
- Cover (1965) Thomas Cover. Behavior of sequential predictors of binary sequences. In Proc. of the 4th Prague Conference on Information Theory, Statistical Decision Functions and Random Processes, pages 263â272. Publishing House of the Czechoslovak Academy of Sciences, 1965.
- Cover and Thomas (1991) Thomas M. Cover and Joy A. Thomas. Elements of Information Theory. John Wiley & Sons, New York, NY, USA, 1991.
- Dani et al. (2007) Varsha Dani, Thomas P. Hayes, and Sham Kakade. The Price of Bandit Information for Online Optimization. In 20th Advances in Neural Information Processing Systems (NIPS), 2007.
- Dani et al. (2008) Varsha Dani, Thomas P. Hayes, and Sham Kakade. Stochastic Linear Optimization under Bandit Feedback. In 21th Conf. on Learning Theory (COLT), pages 355â366, 2008.
- Daskalakis and Pan (2014) Constantinos Daskalakis and Qinxuan Pan. A counter-example to karlinâs strong conjecture for fictitious play. In 55th IEEE Symp. on Foundations of Computer Science (FOCS), pages 11â20, 2014.
- Daskalakis and Panageas (2019) Constantinos Daskalakis and Ioannis Panageas. Last-iterate convergence: Zero-sum games and constrained min-max optimization. In 10th Innovations in Theoretical Computer Science Conf. (ITCS), volume 124, pages 27:1â27:18, 2019.
- Daskalakis et al. (2015) Constantinos Daskalakis, Alan Deckelbaum, and Anthony Kim. Near-optimal no-regret algorithms for zero-sum games. Games and Economic Behavior, 92:327â348, 2015. Preliminary version in ACM-SIAM SODA 2011.
- Daskalakis et al. (2018) Constantinos Daskalakis, Andrew Ilyas, Vasilis Syrgkanis, and Haoyang Zeng. Training gans with optimism. In 6th International Conference on Learning Representations (ICLR), 2018.
- Dekel et al. (2012) Ofer Dekel, Ambuj Tewari, and Raman Arora. Online bandit learning against an adaptive adversary: from regret to policy regret. In 29th Intl. Conf. on Machine Learning (ICML), 2012.
- Desautels et al. (2012) Thomas Desautels, Andreas Krause, and Joel Burdick. Parallelizing exploration-exploitation tradeoffs with gaussian process bandit optimization. In 29th Intl. Conf. on Machine Learning (ICML), 2012.
- Devanur and Kakade (2009) Nikhil Devanur and Sham M. Kakade. The price of truthfulness for pay-per-click auctions. In 10th ACM Conf. on Electronic Commerce (ACM-EC), pages 99â106, 2009.
- Devanur and Hayes (2009) Nikhil R. Devanur and Thomas P. Hayes. The AdWords problem: Online keyword matching with budgeted bidders under random permutations. In 10th ACM Conf. on Electronic Commerce (ACM-EC), pages 71â78, 2009.
- Devanur et al. (2011) Nikhil R. Devanur, Kamal Jain, Balasubramanian Sivan, and Christopher A. Wilkens. Near optimal online algorithms and fast approximation algorithms for resource allocation problems. In 12th ACM Conf. on Electronic Commerce (ACM-EC), pages 29â38, 2011.
- Devanur et al. (2019) Nikhil R. Devanur, Kamal Jain, Balasubramanian Sivan, and Christopher A. Wilkens. Near optimal online algorithms and fast approximation algorithms for resource allocation problems. J. ACM, 66(1):7:1â7:41, 2019. Preliminary version in ACM EC 2011.
- Ding et al. (2013) Wenkui Ding, Tao Qin, Xu-Dong Zhang, and Tie-Yan Liu. Multi-armed bandit with budget constraint and variable costs. In 27th AAAI Conference on Artificial Intelligence (AAAI), 2013.
- Dong et al. (2015) Mo Dong, Qingxi Li, Doron Zarchy, Philip Brighten Godfrey, and Michael Schapira. PCC: re-architecting congestion control for consistent high performance. In 12th USENIX Symp. on Networked Systems Design and Implementation (NSDI), pages 395â408, 2015.
- Dong et al. (2018) Mo Dong, Tong Meng, Doron Zarchy, Engin Arslan, Yossi Gilad, Brighten Godfrey, and Michael Schapira. PCC vivace: Online-learning congestion control. In 15th USENIX Symp. on Networked Systems Design and Implementation (NSDI), pages 343â356, 2018.
- Dubhashi and Panconesi (2009) Devdatt P. Dubhashi and Alessandro Panconesi. Concentration of Measure for the Analysis of Randomized Algorithms. Cambridge University Press, 2009.
- DudĂk et al. (2011) Miroslav DudĂk, Daniel Hsu, Satyen Kale, Nikos Karampatziakis, John Langford, Lev Reyzin, and Tong Zhang. Efficient optimal leanring for contextual bandits. In 27th Conf. on Uncertainty in Artificial Intelligence (UAI), 2011.
- DudĂk et al. (2012) Miroslav DudĂk, Dumitru Erhan, John Langford, and Lihong Li. Sample-efficient nonstationary policy evaluation for contextual bandits. In 28th Conf. on Uncertainty in Artificial Intelligence (UAI), pages 247â254, 2012.
- DudĂk et al. (2014) Miroslav DudĂk, Dumitru Erhan, John Langford, and Lihong Li. Doubly robust policy evaluation and optimization. Statistical Science, 29(4):1097â1104, 2014.
- DudĂk et al. (2015) Miroslav DudĂk, Katja Hofmann, Robert E. Schapire, Aleksandrs Slivkins, and Masrour Zoghi. Contextual dueling bandits. In 28th Conf. on Learning Theory (COLT), 2015.
- DudĂk et al. (2017) Miroslav DudĂk, Nika Haghtalab, Haipeng Luo, Robert E. Schapire, Vasilis Syrgkanis, and Jennifer Wortman Vaughan. Oracle-efficient online learning and auction design. In 58th IEEE Symp. on Foundations of Computer Science (FOCS), pages 528â539, 2017.
- Even-Dar et al. (2002) Eyal Even-Dar, Shie Mannor, and Yishay Mansour. PAC bounds for multi-armed bandit and Markov decision processes. In 15th Conf. on Learning Theory (COLT), pages 255â270, 2002.
- Even-Dar et al. (2006) Eyal Even-Dar, Shie Mannor, and Yishay Mansour. Action elimination and stopping conditions for the multi-armed bandit and reinforcement learning problems. J. of Machine Learning Research (JMLR), 7:1079â1105, 2006.
- Feige et al. (2017) Uriel Feige, Tomer Koren, and Moshe Tennenholtz. Chasing ghosts: Competing with stateful policies. SIAM J. on Computing (SICOMP), 46(1):190â223, 2017. Preliminary version in IEEE FOCS 2014.
- Feldman et al. (2010) Jon Feldman, Monika Henzinger, Nitish Korula, Vahab S. Mirrokni, and Clifford Stein. Online stochastic packing applied to display ad allocation. In 18th Annual European Symp. on Algorithms (ESA), pages 182â194, 2010.
- Feng et al. (2018) Zhe Feng, Chara Podimata, and Vasilis Syrgkanis. Learning to bid without knowing your value. In 19th ACM Conf. on Economics and Computation (ACM-EC), pages 505â522, 2018.
- Filippi et al. (2010) Sarah Filippi, Olivier CappĂ©, AurĂ©lien Garivier, and Csaba SzepesvĂĄri. Parametric bandits: The generalized linear case. In 24th Advances in Neural Information Processing Systems (NIPS), pages 586â594, 2010.
- Flajolet and Jaillet (2015) Arthur Flajolet and Patrick Jaillet. Logarithmic regret bounds for bandits with knapsacks. arXiv preprint arXiv:1510.01800, 2015.
- Flaxman et al. (2005) Abraham Flaxman, Adam Kalai, and H. Brendan McMahan. Online Convex Optimization in the Bandit Setting: Gradient Descent without a Gradient. In 16th ACM-SIAM Symp. on Discrete Algorithms (SODA), pages 385â394, 2005.
- Foster and Vohra (1997) Dean Foster and Rakesh Vohra. Calibrated learning and correlated equilibrium. Games and Economic Behavior, 21:40â55, 1997.
- Foster and Vohra (1998) Dean Foster and Rakesh Vohra. Asymptotic calibration. Biometrika, 85:379â390, 1998.
- Foster and Vohra (1999) Dean Foster and Rakesh Vohra. Regret in the on-line decision problem. Games and Economic Behavior, 29:7â36, 1999.
- Foster and Rakhlin (2020) Dylan J. Foster and Alexander Rakhlin. Beyond UCB: optimal and efficient contextual bandits with regression oracles. In 37th Intl. Conf. on Machine Learning (ICML), 2020.
- Foster et al. (2016a) Dylan J. Foster, Zhiyuan Li, Thodoris Lykouris, Karthik Sridharan, and Ăva Tardos. Learning in games: Robustness of fast convergence. In 29th Advances in Neural Information Processing Systems (NIPS), pages 4727â4735, 2016a.
- Foster et al. (2016b) Dylan J. Foster, Zhiyuan Li, Thodoris Lykouris, Karthik Sridharan, and Ăva Tardos. Learning in games: Robustness of fast convergence. In 29th Advances in Neural Information Processing Systems (NIPS), pages 4727â4735, 2016b.
- Foster et al. (2018) Dylan J. Foster, Alekh Agarwal, Miroslav DudĂk, Haipeng Luo, and Robert E. Schapire. Practical contextual bandits with regression oracles. In 35th Intl. Conf. on Machine Learning (ICML), pages 1534â1543, 2018.
- Frazier et al. (2014) Peter Frazier, David Kempe, Jon M. Kleinberg, and Robert Kleinberg. Incentivizing exploration. In ACM Conf. on Economics and Computation (ACM-EC), pages 5â22, 2014.
- Freund and Schapire (1996) Yoav Freund and Robert E Schapire. Game theory, on-line prediction and boosting. In 9th Conf. on Learning Theory (COLT), pages 325â332, 1996.
- Freund and Schapire (1997) Yoav Freund and Robert E. Schapire. A decision-theoretic generalization of on-line learning and an application to boosting. Journal of Computer and System Sciences, 55(1):119â139, 1997.
- Freund and Schapire (1999) Yoav Freund and Robert E Schapire. Adaptive game playing using multiplicative weights. Games and Economic Behavior, 29(1-2):79â103, 1999.
- Freund et al. (1997) Yoav Freund, Robert E Schapire, Yoram Singer, and Manfred K Warmuth. Using and combining predictors that specialize. In 29th ACM Symp. on Theory of Computing (STOC), pages 334â343, 1997.
- Garivier and Cappé (2011) Aurélien Garivier and Olivier Cappé. The KL-UCB Algorithm for Bounded Stochastic Bandits and Beyond. In 24th Conf. on Learning Theory (COLT), 2011.
- Garivier and Moulines (2011) AurĂ©lien Garivier and Eric Moulines. On upper-confidence bound policies for switching bandit problems. In 22nd Intl. Conf. on Algorithmic Learning Theory (ALT), pages 174â188, 2011.
- Gatti et al. (2012) Nicola Gatti, Alessandro Lazaric, and Francesco Trovo. A Truthful Learning Mechanism for Contextual Multi-Slot Sponsored Search Auctions with Externalities. In 13th ACM Conf. on Electronic Commerce (ACM-EC), 2012.
- Ghosh and Hummel (2013) Arpita Ghosh and Patrick Hummel. Learning and incentives in user-generated content: multi-armed bandits with endogenous arms. In Innovations in Theoretical Computer Science Conf. (ITCS), pages 233â246, 2013.
- Gittins (1979) J. C. Gittins. Bandit processes and dynamic allocation indices (with discussion). J. Roy. Statist. Soc. Ser. B, 41:148â177, 1979.
- Gittins et al. (2011) John Gittins, Kevin Glazebrook, and Richard Weber. Multi-Armed Bandit Allocation Indices. John Wiley & Sons, Hoboken, NJ, USA, 2nd edition, 2011.
- Golovin et al. (2009) Daniel Golovin, Andreas Krause, and Matthew Streeter. Online learning of assignments. In Advances in Neural Information Processing Systems (NIPS), 2009.
- Golowich et al. (2020) Noah Golowich, Sarath Pattathil, and Constantinos Daskalakis. Tight last-iterate convergence rates for no-regret learning in multi-player games. In 33rd Advances in Neural Information Processing Systems (NeurIPS), 2020.
- Golub and Sadler (2016) Benjamin Golub and Evan D. Sadler. Learning in social networks. In Yann Bramoullé, Andrea Galeotti, and Brian Rogers, editors, The Oxford Handbook of the Economics of Networks. Oxford University Press, 2016.
- Gravin et al. (2016) Nick Gravin, Yuval Peres, and Balasubramanian Sivan. Towards optimal algorithms for prediction with expert advice. In 27th ACM-SIAM Symp. on Discrete Algorithms (SODA), pages 528â547, 2016.
- Gravin et al. (2017) Nick Gravin, Yuval Peres, and Balasubramanian Sivan. Tight lower bounds for multiplicative weights algorithmic families. In 44th Intl. Colloquium on Automata, Languages and Programming (ICALP), pages 48:1â48:14, 2017.
- Grill et al. (2015) Jean-Bastien Grill, Michal Valko, and RĂ©mi Munos. Black-box optimization of noisy functions with unknown smoothness. In 28th Advances in Neural Information Processing Systems (NIPS), 2015.
- Gupta et al. (2003) Anupam Gupta, Robert Krauthgamer, and James R. Lee. Bounded geometries, fractals, and lowâdistortion embeddings. In 44th IEEE Symp. on Foundations of Computer Science (FOCS), pages 534â543, 2003.
- Gupta et al. (2019) Anupam Gupta, Tomer Koren, and Kunal Talwar. Better algorithms for stochastic bandits with adversarial corruptions. In Conf. on Learning Theory (COLT), pages 1562â1578, 2019.
- György et al. (2007) AndrĂĄs György, Levente Kocsis, Ivett SzabĂł, and Csaba SzepesvĂĄri. Continuous time associative bandit problems. In 20th Intl. Joint Conf. on Artificial Intelligence (IJCAI), pages 830â835, 2007.
- György et al. (2007) AndrĂĄs György, TamĂĄs Linder, GĂĄbor Lugosi, and György OttucsĂĄk. The on-line shortest path problem under partial monitoring. J. of Machine Learning Research (JMLR), 8:2369â2403, 2007.
- Han et al. (2023) Yuxuan Han, Jialin Zeng, Yang Wang, Yang Xiang, and Jiheng Zhang. Optimal contextual bandits with knapsacks under realizibility via regression oracles. In 26th Intl. Conf. on Artificial Intelligence and Statistics (AISTATS), 2023. Available at arxiv.org/abs/2210.11834 since October 2022.
- Hannan (1957) James Hannan. Approximation to bayes risk in repeated play. Contributions to the Theory of Games, 3:97â139, 1957.
- Hart and Mas-Colell (2000) Sergiu Hart and Andreu Mas-Colell. A simple adaptive procedure leading to correlated equilibrium. Econometrica, 68:1127â1150, 2000.
- Hazan (2015) Elad Hazan. Introduction to Online Convex Optimization. Foundations and Trends in Optimization, 2(3-4):157â325, 2015. Published with Now Publishers (Boston, MA, USA). Also available at https://arxiv.org/abs/1909.05207.
- Hazan and Kale (2011) Elad Hazan and Satyen Kale. Better algorithms for benign bandits. Journal of Machine Learning Research, 12:1287â1311, 2011. Preliminary version published in ACM-SIAM SODA 2009.
- Hazan and Levy (2014) Elad Hazan and Kfir Y. Levy. Bandit convex optimization: Towards tight bounds. In 27th Advances in Neural Information Processing Systems (NIPS), pages 784â792, 2014.
- Hazan and Megiddo (2007) Elad Hazan and Nimrod Megiddo. Online Learning with Prior Information. In 20th Conf. on Learning Theory (COLT), pages 499â513, 2007.
- Heidari et al. (2016) Hoda Heidari, Mohammad Mahdian, Umar Syed, Sergei Vassilvitskii, and Sadra Yazdanbod. Pricing a low-regret seller. In 33rd Intl. Conf. on Machine Learning (ICML), pages 2559â2567, 2016.
- Ho et al. (2016) Chien-Ju Ho, Aleksandrs Slivkins, and Jennifer Wortman Vaughan. Adaptive contract design for crowdsourcing markets: Bandit algorithms for repeated principal-agent problems. J. of Artificial Intelligence Research, 55:317â359, 2016. Preliminary version appeared in ACM EC 2014.
- Hofmann et al. (2016) Katja Hofmann, Lihong Li, and Filip Radlinski. Online evaluation for information retrieval. Foundations and TrendsÂź in Information Retrieval, 10(1):1â117, 2016. Published with Now Publishers (Boston, MA, USA).
- Honda and Takemura (2010) Junya Honda and Akimichi Takemura. An asymptotically optimal bandit algorithm for bounded support models. In 23rd Conf. on Learning Theory (COLT), 2010.
- Hörner and Skrzypacz (2017) Johannes Hörner and Andrzej Skrzypacz. Learning, experimentation, and information design. In Bo HonorĂ©, Ariel Pakes, Monika Piazzesi, and Larry Samuelson, editors, Advances in Economics and Econometrics: 11th World Congress, volume 1, page 63â98. Cambridge University Press, 2017.
- Hsu et al. (2016) Justin Hsu, Zhiyi Huang, Aaron Roth, and Zhiwei Steven Wu. Jointly private convex programming. In 27th ACM-SIAM Symp. on Discrete Algorithms (SODA), pages 580â599, 2016.
- Immorlica et al. (2019) Nicole Immorlica, Jieming Mao, Aleksandrs Slivkins, and Steven Wu. Bayesian exploration with heterogenous agents. In The Web Conference (formerly known as WWW), 2019.
- Immorlica et al. (2020) Nicole Immorlica, Jieming Mao, Aleksandrs Slivkins, and Steven Wu. Incentivizing exploration with selective data disclosure. In ACM Conf. on Economics and Computation (ACM-EC), pages 647â648, 2020. Working paper available at https://arxiv.org/abs/1811.06026.
- Immorlica et al. (2022) Nicole Immorlica, Karthik Abinav Sankararaman, Robert Schapire, and Aleksandrs Slivkins. Adversarial bandits with knapsacks. J. of the ACM, August 2022. Preliminary version in 60th IEEE FOCS, 2019.
- Jedor et al. (2021) Matthieu Jedor, Jonathan Louëdec, and Vianney Perchet. Be greedy in multi-armed bandits, 2021. Working paper, available on https://arxiv.org/abs/2101.01086.
- Jiang et al. (2016) Junchen Jiang, Rajdeep Das, Ganesh Ananthanarayanan, Philip A. Chou, Venkat N. Padmanabhan, Vyas Sekar, Esbjorn Dominique, Marcin Goliszewski, Dalibor Kukoleca, Renat Vafin, and Hui Zhang. Via: Improving internet telephony call quality using predictive relay selection. In ACM SIGCOMM (ACM SIGCOMM Conf. on Applications, Technologies, Architectures, and Protocols for Computer Communications), pages 286â299, 2016.
- Jiang et al. (2017) Junchen Jiang, Shijie Sun, Vyas Sekar, and Hui Zhang. Pytheas: Enabling data-driven quality of experience optimization using group-based exploration-exploitation. In 14th USENIX Symp. on Networked Systems Design and Implementation (NSDI), pages 393â406, 2017.
- Kakade et al. (2013) Sham M. Kakade, Ilan Lobel, and Hamid Nazerzadeh. Optimal dynamic mechanism design and the virtual-pivot mechanism. Operations Research, 61(4):837â854, 2013.
- Kalai and Vempala (2005) Adam Tauman Kalai and Santosh Vempala. Efficient algorithms for online decision problems. J. of Computer and Systems Sciences, 71(3):291â307, 2005. Preliminary version in COLT 2003.
- Kale et al. (2010) Satyen Kale, Lev Reyzin, and Robert E. Schapire. Non-Stochastic Bandit Slate Problems. In 24th Advances in Neural Information Processing Systems (NIPS), pages 1054â1062, 2010.
- Kallus (2018) Nathan Kallus. Instrument-armed bandits. In 29th Intl. Conf. on Algorithmic Learning Theory (ALT), pages 529â546, 2018.
- Kamenica (2019) Emir Kamenica. Bayesian persuasion and information design. Annual Review of Economics, 11(1):249â272, 2019.
- Kamenica and Gentzkow (2011) Emir Kamenica and Matthew Gentzkow. Bayesian Persuasion. American Economic Review, 101(6):2590â2615, 2011.
- Kannan et al. (2018) Sampath Kannan, Jamie Morgenstern, Aaron Roth, Bo Waggoner, and Zhiwei Steven Wu. A smoothed analysis of the greedy algorithm for the linear contextual bandit problem. In Advances in Neural Information Processing Systems (NIPS), pages 2231â2241, 2018.
- Karger and Ruhl (2002) D.R. Karger and M. Ruhl. Finding Nearest Neighbors in Growth-restricted Metrics. In 34th ACM Symp. on Theory of Computing (STOC), pages 63â66, 2002.
- Kaufmann et al. (2012) Emilie Kaufmann, Nathaniel Korda, and RĂ©mi Munos. Thompson sampling: An asymptotically optimal finite-time analysis. In 23rd Intl. Conf. on Algorithmic Learning Theory (ALT), pages 199â213, 2012.
- Kaufmann et al. (2016) Emilie Kaufmann, Olivier CappĂ©, and AurĂ©lien Garivier. On the complexity of best-arm identification in multi-armed bandit models. J. of Machine Learning Research (JMLR), 17:1:1â1:42, 2016.
- Kearns et al. (2018) Michael Kearns, Seth Neel, Aaron Roth, and Zhiwei Steven Wu. Preventing fairness gerrymandering: Auditing and learning for subgroup fairness. In 35th Intl. Conf. on Machine Learning (ICML), pages 2564â2572, 2018.
- Keller and Rady (2003) Godfrey Keller and Sven Rady. Price dispersion and learning in a dynamic differentiated-goods duopoly. RAND Journal of Economics, pages 138â165, 2003.
- Kesselheim and Singla (2020) Thomas Kesselheim and Sahil Singla. Online learning with vector costs and bandits with knapsacks. In 33rd Conf. on Learning Theory (COLT), pages 2286â2305, 2020.
- Kleinberg and Tardos (2005) Jon Kleinberg and Eva Tardos. Algorithm Design. Addison Wesley, 2005.
- Kleinberg et al. (2009a) Jon Kleinberg, Aleksandrs Slivkins, and Tom Wexler. Triangulation and embedding using small sets of beacons. J. of the ACM, 56(6), September 2009a. Subsumes conference papers in IEEE FOCS 2004 and ACM-SIAM SODA 2005.
- Kleinberg (2004) Robert Kleinberg. Nearly tight bounds for the continuum-armed bandit problem. In 18th Advances in Neural Information Processing Systems (NIPS), 2004.
- Kleinberg (2006) Robert Kleinberg. Anytime algorithms for multi-armed bandit problems. In 17th ACM-SIAM Symp. on Discrete Algorithms (SODA), pages 928â936, 2006.
- Kleinberg (2007) Robert Kleinberg. CS683: Learning, Games, and Electronic Markets, a class at Cornell University. Lecture notes, available at http://www.cs.cornell.edu/courses/cs683/2007sp/, Spring 2007.
- Kleinberg and Slivkins (2010) Robert Kleinberg and Aleksandrs Slivkins. Sharp dichotomies for regret minimization in metric spaces. In 21st ACM-SIAM Symp. on Discrete Algorithms (SODA), 2010.
- Kleinberg et al. (2008a) Robert Kleinberg, Alexandru Niculescu-Mizil, and Yogeshwer Sharma. Regret bounds for sleeping experts and bandits. In 21st Conf. on Learning Theory (COLT), pages 425â436, 2008a.
- Kleinberg et al. (2008b) Robert Kleinberg, Aleksandrs Slivkins, and Eli Upfal. Multi-armed bandits in metric spaces. In 40th ACM Symp. on Theory of Computing (STOC), pages 681â690, 2008b.
- Kleinberg et al. (2009b) Robert Kleinberg, Georgios Piliouras, and Ăva Tardos. Multiplicative updates outperform generic no-regret learning in congestion games: extended abstract. In 41st ACM Symp. on Theory of Computing (STOC), pages 533â542, 2009b.
- Kleinberg et al. (2019) Robert Kleinberg, Aleksandrs Slivkins, and Eli Upfal. Bandits and experts in metric spaces. J. of the ACM, 66(4):30:1â30:77, May 2019. Merged and revised version of conference papers in ACM STOC 2008 and ACM-SIAM SODA 2010. Also available at http://arxiv.org/abs/1312.1277.
- Kleinberg and Leighton (2003) Robert D. Kleinberg and Frank T. Leighton. The value of knowing a demand curve: Bounds on regret for online posted-price auctions. In IEEE Symp. on Foundations of Computer Science (FOCS), pages 594â605, 2003.
- Kocsis and Szepesvari (2006) Levente Kocsis and Csaba Szepesvari. Bandit Based Monte-Carlo Planning. In 17th European Conf. on Machine Learning (ECML), pages 282â293, 2006.
- Koolen et al. (2010) Wouter M. Koolen, Manfred K. Warmuth, and Jyrki Kivinen. Hedging structured concepts. In 23rd Conf. on Learning Theory (COLT), 2010.
- Krause and Ong (2011) Andreas Krause and Cheng Soon Ong. Contextual gaussian process bandit optimization. In 25th Advances in Neural Information Processing Systems (NIPS), pages 2447â2455, 2011.
- Kremer et al. (2014) Ilan Kremer, Yishay Mansour, and Motty Perry. Implementing the âwisdom of the crowdâ. J. of Political Economy, 122(5):988â1012, 2014. Preliminary version in ACM EC 2013.
- Krishnamurthy et al. (2016) Akshay Krishnamurthy, Alekh Agarwal, and Miroslav DudĂk. Contextual semibandits via supervised learning oracles. In 29th Advances in Neural Information Processing Systems (NIPS), 2016.
- Krishnamurthy et al. (2020) Akshay Krishnamurthy, John Langford, Aleksandrs Slivkins, and Chicheng Zhang. Contextual bandits with continuous actions: Smoothing, zooming, and adapting. J. of Machine Learning Research (JMLR), 27(137):1â45, 2020. Preliminary version at COLT 2019.
- Kveton et al. (2014) Branislav Kveton, Zheng Wen, Azin Ashkan, Hoda Eydgahi, and Brian Eriksson. Matroid bandits: Fast combinatorial optimization with learning. In 13th Conf. on Uncertainty in Artificial Intelligence (UAI), pages 420â429, 2014.
- Kveton et al. (2015a) Branislav Kveton, Csaba SzepesvĂĄri, Zheng Wen, and Azin Ashkan. Cascading bandits: Learning to rank in the cascade model. In 32nd Intl. Conf. on Machine Learning (ICML), pages 767â776, 2015a.
- Kveton et al. (2015b) Branislav Kveton, Zheng Wen, Azin Ashkan, and Csaba SzepesvĂĄri. Combinatorial cascading bandits. In 28th Advances in Neural Information Processing Systems (NIPS), pages 1450â1458, 2015b.
- Kveton et al. (2015c) Branislav Kveton, Zheng Wen, Azin Ashkan, and Csaba SzepesvĂĄri. Tight regret bounds for stochastic combinatorial semi-bandits. In 18th Intl. Conf. on Artificial Intelligence and Statistics (AISTATS), 2015c.
- Laffont and Martimort (2002) Jean-Jacques Laffont and David Martimort. The Theory of Incentives: The Principal-Agent Model. Princeton University Press, 2002.
- Lai et al. (2008) Lifeng Lai, Hai Jiang, and H. Vincent Poor. Medium access in cognitive radio networks: A competitive multi-armed bandit framework. In 42nd Asilomar Conference on Signals, Systems and Computers, 2008.
- Lai and Robbins (1985) Tze Leung Lai and Herbert Robbins. Asymptotically efficient Adaptive Allocation Rules. Advances in Applied Mathematics, 6:4â22, 1985.
- Langford and Zhang (2007) John Langford and Tong Zhang. The Epoch-Greedy Algorithm for Contextual Multi-armed Bandits. In 21st Advances in Neural Information Processing Systems (NIPS), 2007.
- Lattimore and SzepesvĂĄri (2020) Tor Lattimore and Csaba SzepesvĂĄri. Bandit Algorithms. Cambridge University Press, Cambridge, UK, 2020.
- Li et al. (2010) Lihong Li, Wei Chu, John Langford, and Robert E. Schapire. A contextual-bandit approach to personalized news article recommendation. In 19th Intl. World Wide Web Conf. (WWW), 2010.
- Li et al. (2011) Lihong Li, Wei Chu, John Langford, and Xuanhui Wang. Unbiased offline evaluation of contextual-bandit-based news article recommendation algorithms. In 4th ACM Intl. Conf. on Web Search and Data Mining (WSDM), 2011.
- Li et al. (2015) Lihong Li, Shunbao Chen, Jim Kleban, and Ankur Gupta. Counterfactual estimation and optimization of click metrics in search engines: A case study. In 24th Intl. World Wide Web Conf. (WWW), pages 929â934, 2015.
- Li et al. (2017) Lihong Li, Yu Lu, and Dengyong Zhou. Provably optimal algorithms for generalized linear contextual bandits. In 34th Intl. Conf. on Machine Learning (ICML), volume 70, pages 2071â2080, 2017.
- Li et al. (2016) Shuai Li, Alexandros Karatzoglou, and Claudio Gentile. Collaborative filtering bandits. In 16th ACM Intl. Conf. on Research and Development in Information Retrieval (SIGIR), pages 539â548, 2016.
- Li et al. (2021) Xiaocheng Li, Chunlin Sun, and Yinyu Ye. The symmetry between arms and knapsacks: A primal-dual approach for bandits with knapsacks. In 38th Intl. Conf. on Machine Learning (ICML), 2021.
- Littlestone and Warmuth (1994) Nick Littlestone and Manfred K. Warmuth. The weighted majority algorithm. Information and Computation, 108(2):212â260, 1994.
- Liu and Zhao (2010) Keqin Liu and Qing Zhao. Distributed learning in multi-armed bandit with multiple players. IEEE Trans. Signal Processing, 58(11):5667â5681, 2010.
- Lu et al. (2010) Tyler Lu, DĂĄvid PĂĄl, and Martin PĂĄl. Showing Relevant Ads via Lipschitz Context Multi-Armed Bandits. In 14th Intl. Conf. on Artificial Intelligence and Statistics (AISTATS), 2010.
- Luo et al. (2018) Haipeng Luo, Chen-Yu Wei, Alekh Agarwal, and John Langford. Efficient contextual bandits in non-stationary worlds. In Conf. on Learning Theory (COLT), pages 1739â1776, 2018.
- Lykouris et al. (2016) Thodoris Lykouris, Vasilis Syrgkanis, and Ăva Tardos. Learning and efficiency in games with dynamic population. In 27th ACM-SIAM Symp. on Discrete Algorithms (SODA), pages 120â129, 2016.
- Lykouris et al. (2018a) Thodoris Lykouris, Vahab Mirrokni, and Renato Paes-Leme. Stochastic bandits robust to adversarial corruptions. In 50th ACM Symp. on Theory of Computing (STOC), 2018a.
- Lykouris et al. (2018b) Thodoris Lykouris, Karthik Sridharan, and Ăva Tardos. Small-loss bounds for online learning with partial information. In 31st Conf. on Learning Theory (COLT), pages 979â986, 2018b.
- Magureanu et al. (2014) Stefan Magureanu, Richard Combes, and Alexandre Proutiere. Lipschitz bandits: Regret lower bound and optimal algorithms. In 27th Conf. on Learning Theory (COLT), pages 975â999, 2014.
- Mahdavi et al. (2012) Mehrdad Mahdavi, Rong Jin, and Tianbao Yang. Trading regret for efficiency: online convex optimization with long term constraints. J. of Machine Learning Research (JMLR), 13(Sep):2503â2528, 2012.
- Mahdavi et al. (2013) Mehrdad Mahdavi, Tianbao Yang, and Rong Jin. Stochastic convex optimization with multiple objectives. In Advances in Neural Information Processing Systems (NIPS), pages 1115â1123, 2013.
- Maillard and Munos (2010) Odalric-Ambrym Maillard and RĂ©mi Munos. Online Learning in Adversarial Lipschitz Environments. In European Conf. on Machine Learning and Principles and Practice of Knowledge Discovery in Databases (ECML PKDD), pages 305â320, 2010.
- Maillard et al. (2011) Odalric-Ambrym Maillard, RĂ©mi Munos, and Gilles Stoltz. A finite-time analysis of multi-armed bandits problems with kullback-leibler divergences. In 24th Conf. on Learning Theory (COLT), 2011.
- Majzoubi et al. (2020) Maryam Majzoubi, Chicheng Zhang, Rajan Chari, Akshay Krishnamurthy, John Langford, and Aleksandrs Slivkins. Efficient contextual bandits with continuous actions. In 33rd Advances in Neural Information Processing Systems (NeurIPS), 2020.
- Mannor and Tsitsiklis (2004) Shie Mannor and John N. Tsitsiklis. The sample complexity of exploration in the multi-armed bandit problem. J. of Machine Learning Research (JMLR), 5:623â648, 2004.
- Mansour et al. (2018) Yishay Mansour, Aleksandrs Slivkins, and Steven Wu. Competing bandits: Learning under competition. In 9th Innovations in Theoretical Computer Science Conf. (ITCS), 2018.
- Mansour et al. (2020) Yishay Mansour, Aleksandrs Slivkins, and Vasilis Syrgkanis. Bayesian incentive-compatible bandit exploration. Operations Research, 68(4):1132â1161, 2020. Preliminary version in ACM EC 2015.
- Mansour et al. (2022) Yishay Mansour, Aleksandrs Slivkins, Vasilis Syrgkanis, and Steven Wu. Bayesian exploration: Incentivizing exploration in Bayesian games. Operations Research, 70(2):1105â1127, 2022. Preliminary version in ACM EC 2016.
- McDiarmid (1998) Colin McDiarmid. Concentration. In M. Habib. C. McDiarmid. J. Ramirez and B. Reed, editors, Probabilistic Methods for Discrete Mathematics, pages 195â248. Springer-Verlag, Berlin, 1998.
- McMahan (2017) H. Brendan McMahan. A survey of algorithms and analysis for adaptive online learning. J. of Machine Learning Research (JMLR), 18:90:1â90:50, 2017.
- McMahan and Blum (2004) H. Brendan McMahan and Avrim Blum. Online Geometric Optimization in the Bandit Setting Against an Adaptive Adversary. In 17th Conf. on Learning Theory (COLT), pages 109â123, 2004.
- Merhav et al. (2002) Neri Merhav, Erik Ordentlich, Gadiel Seroussi, and Marcelo J. Weinberger. On sequential strategies for loss functions with memory. IEEE Trans. on Information Theory, 48(7):1947â1958, 2002.
- Mertikopoulos et al. (2018) Panayotis Mertikopoulos, Christos H. Papadimitriou, and Georgios Piliouras. Cycles in adversarial regularized learning. In 29th ACM-SIAM Symp. on Discrete Algorithms (SODA), pages 2703â2717, 2018.
- Minsker (2013) Stanislav Minsker. Estimation of extreme values and associated level sets of a regression function via selective sampling. In 26th Conf. on Learning Theory (COLT), pages 105â121, 2013.
- Molinaro and Ravi (2012) Marco Molinaro and R. Ravi. Geometry of online packing linear programs. In 39th Intl. Colloquium on Automata, Languages and Programming (ICALP), pages 701â713, 2012.
- Moulin and Vial (1978) Herve Moulin and Jean-Paul Vial. Strategically zero-sum games: the class of games whose completely mixed equilibria cannot be improved upon. Intl. J. of Game Theory, 7(3):201â221, 1978.
- Munos (2011) RĂ©mi Munos. Optimistic optimization of a deterministic function without the knowledge of its smoothness. In 25th Advances in Neural Information Processing Systems (NIPS), pages 783â791, 2011.
- Munos (2014) RĂ©mi Munos. From bandits to monte-carlo tree search: The optimistic principle applied to optimization and planning. Foundations and Trends in Machine Learning, 7(1):1â129, 2014.
- Munos and Coquelin (2007) RĂ©mi Munos and Pierre-Arnaud Coquelin. Bandit algorithms for tree search. In 23rd Conf. on Uncertainty in Artificial Intelligence (UAI), 2007.
- Nazerzadeh et al. (2013) Hamid Nazerzadeh, Amin Saberi, and Rakesh Vohra. Dynamic pay-per-action mechanisms and applications to online advertising. Operations Research, 61(1):98â111, 2013. Preliminary version in WWW 2008.
- Neely and Yu (2017) Michael J Neely and Hao Yu. Online convex optimization with time-varying constraints. arXiv preprint arXiv:1702.04783, 2017.
- Nekipelov et al. (2015) Denis Nekipelov, Vasilis Syrgkanis, and Ăva Tardos. Econometrics for learning agents. In 16th ACM Conf. on Electronic Commerce (ACM-EC), pages 1â18, 2015.
- Neu (2015) Gergely Neu. First-order regret bounds for combinatorial semi-bandits. In 28th Conf. on Learning Theory (COLT), 2015.
- Ngo et al. (2021) Daniel Ngo, Logan Stapleton, Vasilis Syrgkanis, and Steven Wu. Incentivizing compliance with algorithmic instrumentsincentivizing compliance with algorithmic instruments. In 38th Intl. Conf. on Machine Learning (ICML), 2021.
- Nisan and Noti (2017) Noam Nisan and Gali Noti. An experimental evaluation of regret-based econometrics. In 26th Intl. World Wide Web Conf. (WWW), pages 73â81, 2017.
- Pandey et al. (2007a) Sandeep Pandey, Deepak Agarwal, Deepayan Chakrabarti, and Vanja Josifovski. Bandits for Taxonomies: A Model-based Approach. In SIAM Intl. Conf. on Data Mining (SDM), 2007a.
- Pandey et al. (2007b) Sandeep Pandey, Deepayan Chakrabarti, and Deepak Agarwal. Multi-armed Bandit Problems with Dependent Arms. In 24th Intl. Conf. on Machine Learning (ICML), 2007b.
- Pavan et al. (2011) Alessandro Pavan, Ilya Segal, and Juuso Toikka. Dynamic Mechanism Design: Revenue Equivalence, Profit Maximization, and Information Disclosure. Working paper, 2011.
- Podimata and Slivkins (2021) Chara Podimata and Aleksandrs Slivkins. Adaptive discretization for adversarial lipschitz bandits. In 34th Conf. on Learning Theory (COLT), 2021.
- Radlinski et al. (2008) Filip Radlinski, Robert Kleinberg, and Thorsten Joachims. Learning diverse rankings with multi-armed bandits. In 25th Intl. Conf. on Machine Learning (ICML), pages 784â791, 2008.
- Raghavan et al. (2023) Manish Raghavan, Aleksandrs Slivkins, Jennifer Wortman Vaughan, and Zhiwei Steven Wu. Greedy algorithm almost dominates in smoothed contextual bandits. SIAM J. on Computing (SICOMP), 52(2):487â524, 2023. Preliminary version at COLT 2018. Working paper available at arxiv.org/abs/2005.10624.
- Rakhlin and Sridharan (2013a) Alexander Rakhlin and Karthik Sridharan. Online learning with predictable sequences. In 26th Conf. on Learning Theory (COLT), volume 30, pages 993â1019, 2013a.
- Rakhlin and Sridharan (2013b) Alexander Rakhlin and Karthik Sridharan. Optimization, learning, and games with predictable sequences. In 27th Advances in Neural Information Processing Systems (NIPS), pages 3066â3074, 2013b.
- Rakhlin and Sridharan (2016) Alexander Rakhlin and Karthik Sridharan. BISTRO: an efficient relaxation-based method for contextual bandits. In 33nd Intl. Conf. on Machine Learning (ICML), 2016.
- Rakhlin et al. (2015) Alexander Rakhlin, Karthik Sridharan, and Ambuj Tewari. Online learning via sequential complexities. J. of Machine Learning Research (JMLR), 16:155â186, 2015.
- Rangi et al. (2019) Anshuka Rangi, Massimo Franceschetti, and Long Tran-Thanh. Unifying the stochastic and the adversarial bandits with knapsack. In 28th Intl. Joint Conf. on Artificial Intelligence (IJCAI), pages 3311â3317, 2019.
- Robinson (1951) Julia Robinson. An iterative method of solving a game. Annals of Mathematics, Second Series, 54(2):296â301, 1951.
- Rogers et al. (2015) Ryan Rogers, Aaron Roth, Jonathan Ullman, and Zhiwei Steven Wu. Inducing approximately optimal flow using truthful mediators. In 16th ACM Conf. on Electronic Commerce (ACM-EC), pages 471â488, 2015.
- Rosenski et al. (2016) Jonathan Rosenski, Ohad Shamir, and Liran Szlak. Multi-player bandits - a musical chairs approach. In 33nd Intl. Conf. on Machine Learning (ICML), pages 155â163, 2016.
- Roth et al. (2016) Aaron Roth, Jonathan Ullman, and Zhiwei Steven Wu. Watch and learn: Optimizing from revealed preferences feedback. In 48th ACM Symp. on Theory of Computing (STOC), pages 949â962, 2016.
- Roth et al. (2017) Aaron Roth, Aleksandrs Slivkins, Jonathan Ullman, and Zhiwei Steven Wu. Multidimensional dynamic pricing for welfare maximization. In 18th ACM Conf. on Electronic Commerce (ACM-EC), pages 519â536, 2017.
- Roughgarden (2009) Tim Roughgarden. Intrinsic robustness of the price of anarchy. In 41st ACM Symp. on Theory of Computing (STOC), pages 513â522, 2009.
- Roughgarden (2016) Tim Roughgarden. Twenty Lectures on Algorithmic Game Theory. Cambridge University Press, 2016.
- Rusmevichientong and Tsitsiklis (2010) Paat Rusmevichientong and John N. Tsitsiklis. Linearly parameterized bandits. Mathematics of Operations Research, 35(2):395â411, 2010.
- Rusmevichientong et al. (2010) Paat Rusmevichientong, Zuo-Jun Max Shen, and David B Shmoys. Dynamic assortment optimization with a multinomial logit choice model and capacity constraint. Operations research, 58(6):1666â1680, 2010.
- Russo and Van Roy (2014) Daniel Russo and Benjamin Van Roy. Learning to optimize via posterior sampling. Mathematics of Operations Research, 39(4):1221â1243, 2014.
- Russo and Van Roy (2016) Daniel Russo and Benjamin Van Roy. An information-theoretic analysis of thompson sampling. J. of Machine Learning Research (JMLR), 17:68:1â68:30, 2016.
- Russo et al. (2018) Daniel Russo, Benjamin Van Roy, Abbas Kazerouni, Ian Osband, and Zheng Wen. A tutorial on thompson sampling. Foundations and Trends in Machine Learning, 11(1):1â96, 2018. Published with Now Publishers (Boston, MA, USA). Also available at https://arxiv.org/abs/1707.02038.
- Sankararaman and Slivkins (2018) Karthik Abinav Sankararaman and Aleksandrs Slivkins. Combinatorial semi-bandits with knapsacks. In Intl. Conf. on Artificial Intelligence and Statistics (AISTATS), pages 1760â1770, 2018.
- Sankararaman and Slivkins (2021) Karthik Abinav Sankararaman and Aleksandrs Slivkins. Bandits with knapsacks beyond the worst-case, 2021. Working paper. Available at https://arxiv.org/abs/2002.00253 since 2020.
- SaurĂ© and Zeevi (2013) Denis SaurĂ© and Assaf Zeevi. Optimal dynamic assortment planning with demand learning. Manufacturing & Service Operations Management, 15(3):387â404, 2013.
- SaurĂ© and Zeevi (2013) Denis SaurĂ© and Assaf Zeevi. Optimal dynamic assortment planning with demand learning. Manufacturing & Service Operations Management, 15(3):387â404, 2013.
- Schmit and Riquelme (2018) Sven Schmit and Carlos Riquelme. Human interaction with recommendation systems. In Intl. Conf. on Artificial Intelligence and Statistics (AISTATS), pages 862â870, 2018.
- Schroeder (1991) Manfred Schroeder. Fractal, Chaos and Power Laws: Minutes from an Infinite Paradise. W. H. Freeman and Co., 1991.
- Schumpeter (1942) Joseph Schumpeter. Capitalism, Socialism and Democracy. Harper & Brothers, 1942.
- Seldin and Lugosi (2016) Yevgeny Seldin and Gabor Lugosi. A lower bound for multi-armed bandits with expert advice. In 13th European Workshop on Reinforcement Learning (EWRL), 2016.
- Seldin and Lugosi (2017) Yevgeny Seldin and GĂĄbor Lugosi. An improved parametrization and analysis of the EXP3++ algorithm for stochastic and adversarial bandits. In 30th Conf. on Learning Theory (COLT), 2017.
- Seldin and Slivkins (2014) Yevgeny Seldin and Aleksandrs Slivkins. One practical algorithm for both stochastic and adversarial bandits. In 31th Intl. Conf. on Machine Learning (ICML), 2014.
- Sellke (2019) Mark Sellke, 2019. Personal communication.
- Sellke and Slivkins (2022) Mark Sellke and Aleksandrs Slivkins. The price of incentivizing exploration: A characterization via thompson sampling and sample complexity. Operations Research, 71(5), 2022. Preliminary version in ACM EC 2021.
- Shalev-Shwartz (2012) Shai Shalev-Shwartz. Online learning and online convex optimization. Foundations and Trends in Machine Learning, 4(2):107â194, 2012.
- Shamir (2015) Ohad Shamir. On the complexity of bandit linear optimization. In 28th Conf. on Learning Theory (COLT), pages 1523â1551, 2015.
- Simchi-Levi and Xu (2020) David Simchi-Levi and Yunzong Xu. Bypassing the monster: A faster and simpler optimal algorithm for contextual bandits under realizability, 2020. Working paper, available at https://arxiv.org/abs/2003.12699.
- Simchowitz and Slivkins (2023) Max Simchowitz and Aleksandrs Slivkins. Incentives and exploration in reinforcement learning. Operations Research, 2023. Ahead of Print. Working paper at arxiv.org since 2021.
- Simchowitz et al. (2016) Max Simchowitz, Kevin G. Jamieson, and Benjamin Recht. Best-of-k-bandits. In 29th Conf. on Learning Theory (COLT), volume 49, pages 1440â1489, 2016.
- Singla and Krause (2013) Adish Singla and Andreas Krause. Truthful incentives in crowdsourcing tasks using regret minimization mechanisms. In 22nd Intl. World Wide Web Conf. (WWW), pages 1167â1178, 2013.
- Slivkins (2007) Aleksandrs Slivkins. Towards fast decentralized construction of locality-aware overlay networks. In 26th Annual ACM Symp. on Principles Of Distributed Computing (PODC), pages 89â98, 2007.
- Slivkins (2011) Aleksandrs Slivkins. Multi-armed bandits on implicit metric spaces. In 25th Advances in Neural Information Processing Systems (NIPS), 2011.
- Slivkins (2013) Aleksandrs Slivkins. Dynamic ad allocation: Bandits with budgets. A technical report on arxiv.org/abs/1306.0155, June 2013.
- Slivkins (2014) Aleksandrs Slivkins. Contextual bandits with similarity information. J. of Machine Learning Research (JMLR), 15(1):2533â2568, 2014. Preliminary version in COLT 2011.
- Slivkins (2023) Aleksandrs Slivkins. Exploration and persuasion. In Federico Echenique, Nicole Immorlica, and Vijay Vazirani, editors, Online and Matching-Based Market Design. Cambridge University Press, 2023. Also available at http://slivkins.com/work/ExplPers.pdf.
- Slivkins and Upfal (2008) Aleksandrs Slivkins and Eli Upfal. Adapting to a changing environment: the Brownian restless bandits. In 21st Conf. on Learning Theory (COLT), pages 343â354, 2008.
- Slivkins and Vaughan (2013) Aleksandrs Slivkins and Jennifer Wortman Vaughan. Online decision making in crowdsourcing markets: Theoretical challenges. SIGecom Exchanges, 12(2):4â23, December 2013.
- Slivkins et al. (2013) Aleksandrs Slivkins, Filip Radlinski, and Sreenivas Gollapudi. Ranked bandits in metric spaces: Learning optimally diverse rankings over large document collections. J. of Machine Learning Research (JMLR), 14(Feb):399â436, 2013. Preliminary version in 27th ICML, 2010.
- Slivkins et al. (2023) Aleksandrs Slivkins, Karthik Abinav Sankararaman, and Dylan J. Foster. Contextual bandits with packing and covering constraints: A modular lagrangian approach via regression. In 36th Conf. on Learning Theory (COLT), 2023.
- Srinivas et al. (2010) Niranjan Srinivas, Andreas Krause, Sham Kakade, and Matthias Seeger. Gaussian Process Optimization in the Bandit Setting: No Regret and Experimental Design. In 27th Intl. Conf. on Machine Learning (ICML), pages 1015â1022, 2010.
- Stoltz (2005) Gilles Stoltz. Incomplete Information and Internal Regret in Prediction of Individual Sequences. PhD thesis, University Paris XI, ORSAY, 2005.
- Streeter and Golovin (2008) Matthew Streeter and Daniel Golovin. An online algorithm for maximizing submodular functions. In Advances in Neural Information Processing Systems (NIPS), pages 1577â1584, 2008.
- Sun et al. (2017) Wen Sun, Debadeepta Dey, and Ashish Kapoor. Safety-aware algorithms for adversarial contextual bandit. In 34th Intl. Conf. on Machine Learning (ICML), pages 3280â3288, 2017.
- Sutton and Barto (1998) Richard S. Sutton and Andrew G. Barto. Reinforcement Learning: An Introduction. MIT Press, 1998.
- Swaminathan and Joachims (2015) Adith Swaminathan and Thorsten Joachims. Batch learning from logged bandit feedback through counterfactual risk minimization. J. of Machine Learning Research (JMLR), 16:1731â1755, 2015.
- Swaminathan et al. (2017) Adith Swaminathan, Akshay Krishnamurthy, Alekh Agarwal, Miroslav DudĂk, John Langford, Damien Jose, and Imed Zitouni. Off-policy evaluation for slate recommendation. In 30th Advances in Neural Information Processing Systems (NIPS), pages 3635â3645, 2017.
- Syrgkanis and Tardos (2013) Vasilis Syrgkanis and Ăva Tardos. Composable and efficient mechanisms. In 45th ACM Symp. on Theory of Computing (STOC), pages 211â220, 2013.
- Syrgkanis et al. (2015) Vasilis Syrgkanis, Alekh Agarwal, Haipeng Luo, and Robert E. Schapire. Fast convergence of regularized learning in games. In 28th Advances in Neural Information Processing Systems (NIPS), pages 2989â2997, 2015.
- Syrgkanis et al. (2016a) Vasilis Syrgkanis, Akshay Krishnamurthy, and Robert E. Schapire. Efficient algorithms for adversarial contextual learning. In 33nd Intl. Conf. on Machine Learning (ICML), 2016a.
- Syrgkanis et al. (2016b) Vasilis Syrgkanis, Haipeng Luo, Akshay Krishnamurthy, and Robert E. Schapire. Improved regret bounds for oracle-based adversarial contextual bandits. In 29th Advances in Neural Information Processing Systems (NIPS), 2016b.
- SzepesvĂĄri (2010) Csaba SzepesvĂĄri. Algorithms for Reinforcement Learning. Synthesis Lectures on Artificial Intelligence and Machine Learning. Morgan & Claypool Publishers, 2010.
- Talwar (2004) Kunal Talwar. Bypassing the embedding: Algorithms for low-dimensional metrics. In 36th ACM Symp. on Theory of Computing (STOC), pages 281â290, 2004.
- Thompson (1933) William R. Thompson. On the likelihood that one unknown probability exceeds another in view of the evidence of two samples. Biometrika, 25(3-4):285â294, 1933.
- Tran-Thanh et al. (2010) Long Tran-Thanh, Archie Chapman, Enrique Munoz de Cote, Alex Rogers, and Nicholas R. Jennings. $\epsilon$ -first policies for budget-limited multi-armed bandits. In 24th AAAI Conference on Artificial Intelligence (AAAI), pages 1211â1216, 2010.
- Tran-Thanh et al. (2012) Long Tran-Thanh, Archie Chapman, Alex Rogers, and Nicholas R. Jennings. Knapsack based optimal policies for budget-limited multi-armed bandits. In 26th AAAI Conference on Artificial Intelligence (AAAI), pages 1134â1140, 2012.
- Valko et al. (2013) Michal Valko, Alexandra Carpentier, and RĂ©mi Munos. Stochastic simultaneous optimistic optimization. In 30th Intl. Conf. on Machine Learning (ICML), pages 19â27, 2013.
- Vera et al. (2020) Alberto Vera, Siddhartha Banerjee, and Itai Gurvich. Online allocation and pricing: Constant regret via bellman inequalities. Operations Research, 2020.
- Wang and Abernethy (2018) Jun-Kun Wang and Jacob D. Abernethy. Acceleration through optimistic no-regret dynamics. In 31st Advances in Neural Information Processing Systems (NIPS), pages 3828â3838, 2018.
- Wang et al. (2014) Zizhuo Wang, Shiming Deng, and Yinyu Ye. Close the gaps: A learning-while-doing algorithm for single-product revenue management problems. Operations Research, 62(2):318â331, 2014.
- Weed et al. (2016) Jonathan Weed, Vianney Perchet, and Philippe Rigollet. Online learning in repeated auctions. In 29th Conf. on Learning Theory (COLT), volume 49, pages 1562â1583, 2016.
- Wei and Luo (2018) Chen-Yu Wei and Haipeng Luo. More adaptive algorithms for adversarial bandits. In 31st Conf. on Learning Theory (COLT), 2018.
- Wei et al. (2021) Chen-Yu Wei, Chung-Wei Lee, Mengxiao Zhang, and Haipeng Luo. Linear last-iterate convergence in constrained saddle-point optimization. In 9th International Conference on Learning Representations (ICLR), 2021.
- Wilkens and Sivan (2012) Chris Wilkens and Balasubramanian Sivan. Single-call mechanisms. In 13th ACM Conf. on Electronic Commerce (ACM-EC), 2012.
- Wu et al. (2015) Huasen Wu, R. Srikant, Xin Liu, and Chong Jiang. Algorithms with logarithmic or sublinear regret for constrained contextual bandits. In 28th Advances in Neural Information Processing Systems (NIPS), 2015.
- Yan (2011) Qiqi Yan. Mechanism design via correlation gap. In 22nd ACM-SIAM Symp. on Discrete Algorithms (SODA), 2011.
- Yu and Mannor (2011) Jia Yuan Yu and Shie Mannor. Unimodal bandits. In 28th Intl. Conf. on Machine Learning (ICML), pages 41â48, 2011.
- Yue and Joachims (2009) Yisong Yue and Thorsten Joachims. Interactively optimizing information retrieval systems as a dueling bandits problem. In 26th Intl. Conf. on Machine Learning (ICML), pages 1201â1208, 2009.
- Yue et al. (2012) Yisong Yue, Josef Broder, Robert Kleinberg, and Thorsten Joachims. The k-armed dueling bandits problem. J. Comput. Syst. Sci., 78(5):1538â1556, 2012. Preliminary version in COLT 2009.
- Zimmert and Lattimore (2019) Julian Zimmert and Tor Lattimore. Connections between mirror descent, thompson sampling and the information ratio. In 33rd Advances in Neural Information Processing Systems (NeurIPS), 2019.
- Zimmert and Seldin (2019) Julian Zimmert and Yevgeny Seldin. An optimal algorithm for stochastic and adversarial bandits. In Intl. Conf. on Artificial Intelligence and Statistics (AISTATS), 2019.
- Zimmert and Seldin (2021) Julian Zimmert and Yevgeny Seldin. Tsallis-inf: An optimal algorithm for stochastic and adversarial bandits. J. of Machine Learning Research (JMLR), 22:28:1â28:49, 2021.
- Zimmert et al. (2019) Julian Zimmert, Haipeng Luo, and Chen-Yu Wei. Beating stochastic and adversarial semi-bandits optimally and simultaneously. In 36th Intl. Conf. on Machine Learning (ICML), pages 7683â7692, 2019.
- Zoghi et al. (2014) Masrour Zoghi, Shimon Whiteson, RĂ©mi Munos, and Maarten de Rijke. Relative upper confidence bound for the $k$ -armed dueling bandits problem. In Intl. Conf. on Machine Learning (ICML), pages 10â18, 2014.
- Zong et al. (2016) Shi Zong, Hao Ni, Kenny Sung, Nan Rosemary Ke, Zheng Wen, and Branislav Kveton. Cascading bandits for large-scale recommendation problems. In 32nd Conf. on Uncertainty in Artificial Intelligence (UAI), 2016.