Taming the Monster: A Fast and Simple Algorithm for Contextual Bandits II: The Iteration Bound of Coordinate DescentResearch Paper
Motivation
In the contextual bandit problem a learner repeatedly observes a context, picks one of actions, and sees the reward of that action only. Against a finite class of policies, statistically optimal regret of order has been known since EXP4 (Auer et al., 2002), but EXP4 maintains a weight per policy and costs time per round. For the large policy classes used in practice (linear classifiers, trees), that is prohibitive.
The oracle-efficient line of work accesses only through a cost-sensitive classification oracle (an arg max oracle, AMO). The RandomizedUCB algorithm of Dudík et al. (2011) obtains optimal regret with polynomially many oracle calls by solving a convex program in each round, but the number of calls is large. Agarwal, Hsu, Kale, Langford, Li and Schapire (2014) replace that solver by a coordinate descent method whose number of iterations, and hence of oracle calls, is bounded independently of . Their algorithm, ILOVETOCONBANDITS, and its practical variant are now standard references for oracle-based exploration.
This mission formalizes the optimization half of that paper: Algorithm 2 solves the per-epoch problem (OP) after at most coordinate steps.
Setting
Let be the actions, any set of contexts, and a finite nonempty set of policies. A history is a sequence of records with the observed reward and the probability with which was chosen. Write .
The inverse propensity scoring estimate (Eq. (1)) is
the estimated regret is , and for a minimum probability one sets with .
Weights are vectors ; is the set of nonnegative with . The smoothed projection of is
The optimization problem (OP) asks for with
Algorithm 2 starts from and loops. With , and : if it rescales by (Eq. (4)); then, if some has , it adds
to (Step 8) and repeats; otherwise it halts and outputs .
The analysis uses the potential (Eq. (6)), with and uniform on ,
Formalization targets
Goal: Theorem 3 (p. 6)
For , Algorithm 2 with satisfies: every run executes Step 8 at most
times, whatever policy each Step 8 chooses among those with ; and when it halts, its output solves (OP). The bound depends on only, not on or .
Milestones
- Lemma 5 (p. 10). If Algorithm 2 halts and outputs , then satisfies (2), (3) and .
- Lemma 6 (p. 10). If and is as in Eq. (4), then .
- Lemma 7 (p. 10). If and adds to , then
Significance
The result. Theorem 3 is what makes ILOVETOCONBANDITS computationally efficient: each call of Algorithm 2 is implemented with one AMO call per iteration (Lemma 1 of the paper), so the oracle complexity of an epoch is . Combined with the epoch schedule and warm start, this gives the paper's total of oracle calls over rounds. Theorem 3 also gives a constructive proof that (OP) is feasible for every history, which the regret analysis (a separate mission in this series) assumes.
Formalizing it. The result is proved in the paper, with complete proofs of Lemmas 5–7 in Appendix D. No machine-checked version is known. The formalization would give a checked termination bound for a coordinate descent method on a non-smooth feasibility problem, with a fully explicit constant, and a verified definition of the unnormalized relative entropy potential that is reusable for other smoothed-projection analyses (e.g. RandomizedUCB-type convex programs).
Difficulty
Termination cannot be read off the constraints. Step 8 raises one weight and can push the total weight above 1, after which Step 5 shrinks every coordinate, so no constraint and no single weight moves monotonically along a run. The number of policies that violate (3) can also go up after a step. Bounding the number of iterations therefore needs a global quantity that tracks progress through both kinds of step. The rescaling step is the harder of the two: it lowers every at once, which pushes the relative-entropy term the wrong way, and it must be offset by the drop in the regret term. Knowing that (OP) is feasible, or that some convex function has a minimizer, bounds nothing about how many steps a particular method takes; that is the obvious approach, and it gives no count.
Formalization scope
- Actions are
Fin Kwith ; contexts form an arbitrary type (no measure is needed: Theorem 3 is deterministic). is a nonemptyFinset (X → Fin K); weights are real functions on its subtype. - Histories are indexed by
Fin twith (0-based indices). The paper allows ; the formalization requires , since Eq. (1) divides by it. - is written as , which equals for any maximizer ; is hard-wired in .
- , , , (OP) and all use the smoothed projection of the unnormalized weights; there is no default policy in this mission.
- ranges over , the range of in Algorithm 1 that the printed theorem refers to. in is the history length .
- Algorithm 2 is encoded relationally. A run of length from is a sequence in which each is Step 8, for some policy with , applied to the rescaled . It halts at when no policy has after rescaling, and it then outputs the rescaled . "Iterations" means executions of Step 8. The last pass, which halts at Step 10, is not counted: the paper's proof bounds "the number of times Step 8 is executed". The bound is compared in , without rounding.
- Lemmas 5–7 are stated for nonnegative weight vectors without a bound on their sum, because Algorithm 2 rescales vectors whose sum may exceed 1. Lemma 7's "" is part of its conclusion.
- A trivializing formalization is ruled out: the goal quantifies over every run from and every choice in Step 8, not over some run, and the potential, and are computed from the history rather than taken as free parameters.
- The auxiliary facts and are inline claims in the paper and are not stated separately; contributions stating and proving them are welcome, as are general lemmas on the unnormalized relative entropy.
- Out of scope: the regret bound (Theorem 2) and the probabilistic model (mission I of this series), the AMO implementation (Lemma 1), warm start and epoch-level oracle counts (Lemmas 2, 3, 8), and the support lower bound (Theorem 4).
Selected references
- A. Agarwal, D. Hsu, S. Kale, J. Langford, L. Li, R. E. Schapire, Taming the Monster: A Fast and Simple Algorithm for Contextual Bandits, ICML 2014; arXiv:1402.0555v2. https://arxiv.org/abs/1402.0555
- M. Dudík, D. Hsu, S. Kale, N. Karampatziakis, J. Langford, L. Reyzin, T. Zhang, Efficient Optimal Learning for Contextual Bandits, UAI 2011. https://arxiv.org/abs/1106.2369
- P. Auer, N. Cesa-Bianchi, Y. Freund, R. E. Schapire, The Nonstochastic Multiarmed Bandit Problem, SIAM J. Comput. 32(1), 2002. https://doi.org/10.1137/S0097539701398375