Title: META-LEARNING FOR CONTEXTUAL BANDIT EXPLORATION

Abstract: We describe MÊLÉE, a meta-learning algorithm for learning a good exploration policy in the interactive contextual bandit setting. Here, an algorithm must take actions based on contexts, and learn based only on a reward signal from the action taken, thereby generating an exploration/exploitation trade-off. MÊLÉE addresses this trade-off by learning a good exploration strategy based on offline synthetic tasks, on which it can simulate the contextual bandit setting. Based on these simulations, MÊLÉE uses an imitation learning strategy to learn a good exploration policy that can then be applied to true contextual bandit tasks at test time. We compare MÊLÉE to seven strong baseline contextual bandit algorithms on a set of three hundred real-world datasets, on which it outperforms alternatives in most settings, especially when differences in rewards are large. Finally, we demonstrate the importance of having a rich feature representation for learning how to explore.

1. INTRODUCTION:

In a contextual bandit problem, an agent attempts to optimize its behavior over a sequence of rounds based on limited feedback (Kaelbling, 1994; Auer, 2003; Langford & Zhang, 2008) . In each round, the agent chooses an action based on a context (features) for that round, and observes a reward for that action but no others ( §2). Contextual bandit problems arise in many real-world settings like online recommendations and personalized medicine. As in reinforcement learning, the agent must learn to balance exploitation (taking actions that, based on past experience, it believes will lead to high instantaneous reward) and exploration (trying actions that it knows less about).

In this paper, we present a meta-learning approach to automatically learn a good exploration mechanism from data. To achieve this, we use supervised learning data sets on which we can simulate contextual bandit tasks. Based on these simulations, our algorithm, MÊLÉE (MEta LEarner for Exploration)1 , learns a good heuristic exploration strategy that should ideally generalize to future contextual bandit problems. MÊLÉE contrasts with more classical approaches to exploration (like -greedy or LinUCB; see §4), in which exploration strategies are constructed by hand and by expert algorithm designer. These approaches often achieve provably good exploration strategies in the worst case, but are potentially overly pessimistic and are sometimes computationally intractable.

At training time ( §2.3), MÊLÉE simulates many contextual bandit problems from fully labeled data. Using this data, in each round, MÊLÉE is able to counterfactually simulate what would happen under all possible action choices. We can then use this information to compute regret estimates for each action, which can be optimized using the AggreVaTe imitation learning algorithm (Ross & Bagnell, 2014) . Our imitation learning strategy mirrors that of the meta-learning approach of Bachman et al. (2017) in the active learning setting. We present a simplified, stylized analysis of the behavior of MÊLÉE to ensure that our cost function encourages good behavior ( § 2.4). Empirically, we use MÊLÉE to train an exploration policy on only synthetic datasets and evaluate the resulting bandit performance across three hundred (simulated) contextual bandit tasks ( §3.2), comparing to a number of alternative exploration algorithms, and showing the efficacy of our approach ( §3.4).

2. META-LEARNING FOR CONTEXTUAL BANDITS:

Contextual bandits is a model of interaction in which an agent chooses actions (based on contexts) and receives immediate rewards for that action alone. For example, in a simplified news personalization setting, at each time step t, a user arrives and the system must choose a news article to display to them. Each possible news article corresponds to an action a, and the user corresponds to a context x t . After the system chooses an article a t to display, it can observe, for instance, the amount of time that the user spends reading that article, which it can use as a reward r t (a t ). The goal of the system is to choose articles to display that maximize the cumulative sum of rewards, but it has to do this without ever being able to know what the reward would have been had it shown a different article a t .

Formally, we largely follow the setup and notation of Agarwal et al. (2014) . Let X be an input space of contexts (users) and [K] = {1, . . . , K} be a finite action space (articles). We consider the statistical setting in which there exists a fixed but unknown distribution D over pairs (x, r) ∈ X×[0, 1] K , where r is a vector of rewards (for convenience, we assume all rewards are bounded in [0, 1]). In this setting, the world operates iteratively over rounds t = 1, 2, . . . . At each round t:

1. The world draws (x t , r t ) ∼ D and reveals context x t . 2. The agent (randomly) chooses action a t ∈ [K] based on x t , and observes reward r t (a t ).

The goal of an algorithm is to maximize the cumulative sum of rewards over time. Typically the primary quantity considered is the average regret of a sequence of actions a 1 , . . . , a T to the behavior of the best possible function in a prespecified class F:

EQUATION

An agent is call no-regret if its average regret is zero in the limit of large T .

2.1. POLICY OPTIMIZATION OVER FIXED HISTORIES:

To produce a good agent for interacting with the world, we assume access to a function class F and to an oracle policy optimizer for that function class. For example, F may be a set of single layer neural networks mapping user features (e.g., IP, browser, etc.) x ∈ X to predicted rewards for actions (articles) a ∈ [K], where K is the total number of actions. Formally, the observable record of interaction resulting from round t is the tuple (x t , a t , r t (a t ), p t (a t ))

∈ X×[K]×[0, 1]×[0, 1],

where p t (a t ) is the probability that the agent chose action a t , and the full history of interaction is

h t = (x i , a i , r i (a i ), p i (a i )) t i=1 .

The oracle policy optimizer, POLOPT, takes as input a history of user interactions with the news recommendation system and outputs an f ∈ F with low expected regret.

A standard example of a policy optimizer is to combine inverse propensity scaling (IPS) with a regression algorithm (Dudik et al., 2011) . Here, given a history h, each tuple (x, a, r, p) in that history is mapped to a multiple-output regression example. The input for this regression example is the same x; the output is a vector of K costs, all of which are zero except the a th component, which takes value r/p. For example, if the agent chose to show to user x article 3, made that decision with 80% probability, and received a reward of 0.6, then the corresponding output vector would be 0, 0, 0.75, 0, . . . , 0 . This mapping is done for all tuples in the history, and then a supervised learning algorithm on the function class F is used to produce a low-regret regressor f . This is the function returned by the policy optimizer.

IPS has this nice property that it is an unbiased estimator; unfortunately, it tends to have large variance especially when some probabilities p are small. In addition to IPS, there are several standard policy optimizers that mostly attempt to reduce variance while remaining unbiased: the direct method (which estimates the reward function from given data and uses this estimate in place of actual reward), the double-robust estimator, and multitask regression. In our experiments, we use the direct method because we found it best on average, but in principle any could be used.

2.2. TEST TIME BEHAVIOR OF MÊLÉE:

In order to have an effective approach to the contextual bandit problem, one must be able to both optimize a policy based on historic data and make decisions about how to explore. After all, in order for the example news recommendation system to learn whether a particular user is interested in news articles on some topic is to try showing such articles to see how the user responds (or to generalize from related articles or users). The exploration/exploitation dilemma is fundamentally about longterm payoffs: is it worth trying something potentially suboptimal now in order to learn how to behave better in the future? A particularly simple and effective form of exploration is -greedy: given a function f output by POLOPT, act according to f (x) with probability (1 -) and act uniformly at random with probability . Intuitively, one would hope to improve on such a strategy by taking more (any!) information into account; for instance, basing the probability of exploration on f 's uncertainty.

Our goal in this paper is to learn how to explore from experience. The training procedure for MÊLÉE will use offline supervised learning problems to learn an exploration policy π, which takes two inputs: a function f ∈ F and a context x, and outputs an action. In our example, f will be the output of the policy optimizer on all historic data, and x will be the current user. This is used to produce an agent which interacts with the world, maintaining an initially empty history buffer h, as:

1. The world draws (x t , r t ) ∼ D and reveals context x t . 2. The agent computes f t ← POLOPT(h) and a greedy action ãt = π(f t , x t ). 3. The agent plays a t = ãt with probability (1 -µ), and a t uniformly at random otherwise. 4. The agent observes r t (a t ) and appends (x t , a t , r t (a t ), p t ) to the history h, where p t = µ/K if a t = ãt ; and

p t = 1 -µ + µ/K if a t = ãt .

Here, f t is the function optimized on the historical data, and π uses it and x t to choose an action.

Intuitively, π might choose to use the prediction f t (x t ) most of the time, unless f t is quite uncertain on this example, in which case π might choose to return the second (or third) most likely action according to f t . The agent then performs a small amount of additional µ-greedy-style exploration: most of the time it acts according to π but occasionally it explores some more. In practice ( §3), we find that setting µ = 0 is optimal in aggregate, but non-zero µ is necessary for our theory ( §2.4).

2.3. TRAINING MÊLÉE BY IMITATION LEARNING:

The meta-learning challenge is: how do we learn a good exploration policy π? We assume we have access to fully labeled data on which we can train π; this data must include context/reward pairs, but where the reward for all actions is known. This is a weak assumption: in practice, we use purely synthetic data as this training data; one could alternatively use any fully labeled classification dataset (this is inspired by Beygelzimer & Langford (2009) ). Under this assumption about the data, it is natural to think of π's behavior as a sequential decision making problem in a simulated setting, for which a natural class of learning algorithms to consider are imitation learning algorithms (Daumé et al., 2009; Ross et al., 2011; Ross & Bagnell, 2014; Chang et al., 2015) .2 Informally, at training time, MÊLÉE will treat one of these synthetic datasets as if it were a contextual bandit dataset. At each time step t, it will compute f t by running POLOPT on the historical data, and then ask: for each action, what would the long time reward look like if I were to take this action. Because the training data for MÊLÉE is fully labeled, this can be evaluated for each possible action, and a policy π can be learned to maximize these rewards.

Importantly, we wish to train π using one set of tasks (for which we have fully supervised data on which to run simulations) and apply it to wholly different tasks (for which we only have bandit feedback). To achieve this, we allow π to depend representationally on f t in arbitrary ways: for instance, it might use features that capture f t 's uncertainty on the current example (see § 3.1 for details). We additionally allow π to depend in a task-independent manner on the history (for instance, which actions have not yet been tried): it can use features of the actions, rewards and probabilities in the history but not depend directly on the contexts x. This is to ensure that π only learns to explore and not also to solve the underlying task-dependent classification problem.

More formally, in imitation learning, we assume training-time access to an expert, π , whose behavior we wish to learn to imitate at test-time. From this, we can define an optimal reference policy π , which effectively "cheats" at training time by looking at the true labels. The learning problem is then to estimate π to have as similar behavior to π as possible, but without access to those labels. Suppose we wish to learn an exploration policy π for a contextual bandit problem for round t = 1, 2, . . . , |Tr| do

6: let (x t , r t ) = Tr t 7:

for each action a = 1, . . . , K do

8: optimize f t,a = POLOPT(F, h t-1 ⊕ (x t , a, r t (a), 1-(K-1)µ)) on augmented history 9:

roll-out: estimate ρa , the value of a, using r t (a) and a roll-out policy π out 10:

end for

11: compute f t = POLOPT(F, h t-1 ) 12: aggregate D ← D ⊕ (Φ(f t , x t , h t-1 , Val), ρ1 , . . . , ρK ) 13:

roll-in:

a t ∼ µ K 1 K + (1 -µ)π n-1 (f t , x t ) with probability p t , 1 is an indicator function 14: append history h t ← h t-1 ⊕ (x t , a t , r t (a t ), p t ) 15:

end for 16:

update π n = LEARN(D) 17: end for 18: return {π n } N n=1 with K actions. We assume access to M supervised learning datasets S 1 , . . . , S M , where each S m = {(x 1 , r 1 ), . . . , (x Nm , r Nm )} of size N m , where each x n is from a (possibly different) input space X m and the reward vectors are all in [0, 1] K .We wish to learn an exploration policy π with maximal reward: ergo, π should imitate a π that always chooses its action optimally.

We additionally allow π to depend on a very small amount of fully labeled data from the task at hand, which we use to allow π to calibrate f t 's predictions. 3The imitation learning algorithm we use is AggreVaTe (Ross & Bagnell, 2014) (closely related to DAgger (Ross et al., 2011 )), and is instantiated for the contextual bandits meta-learning problem in Alg 1. MÊLÉE operates in an iterative fashion, starting with an arbitrary π and improving it through interaction with an expert. Over N rounds, MÊLÉE selects random training sets and simulates the test-time behavior on that training set. The core functionality is to generate a number of states (f t , x t ) on which to train π, and to use the supervised data to estimate the value of every action from those states. MÊLÉE achieves this by sampling a random supervised training set and setting aside some validation data from it (line 3). It then simulates a contextual bandit problem on this training data; at each time step t, it tries all actions and "pretends" like they were appended to the current history (line 8) on which it trains a new policy and evaluates it's roll-out value (line 9, described below). This yields, for each t, a new training example for π, which is added to π's training set (line 12); the features for this example are features of the classifier based on true history (line 11) (and possibly statistics of the history itself), with a label that gives, for each action, the corresponding value of that action (the ρ a s computed in line 9). MÊLÉE then must commit to a roll-in action to actually take; it chooses this according to a roll-in policy (line 13), described below.

The two key questions are: how to choose roll-in actions and how to evaluate roll-out values.

Roll-in actions. The distribution over states visited by MÊLÉE depends on the actions taken, and in general it is good to have that distribution match what is seen at test time as closely as possible. This distribution is determined by a roll-in policy (line 13), controlled in MÊLÉE by exploration parameter µ ∈ [0, 1/K]. As µ → 1/K, the roll-in policy approaches a uniform random policy; as µ → 0, the roll-in policy becomes deterministic. When the roll-in policy does not explore, it acts according to π(f t , .).

Roll-out values. The ideal value to assign to an action (from the perspective of the imitation learning procedure) is that total reward (or advantage) that would be achieved in the long run if we took this action and then behaved according to our final learned policy. Unfortunately, during training, we do not yet know the final learned policy. Thus, a surrogate roll-out policy π out is used instead. A convenient, and often computationally efficient alternative, is to evaluate the value assuming all future actions were taken by the expert (Langford & Zadrozny, 2005; Daumé et al., 2009; Ross & Bagnell, 2014) . In our setting, at any time step t, the expert has access to the fully supervised reward vector r t for the context x t . When estimating the roll-out value for an action a, the expert will return the true reward value for this action r t (a) and we use this as our estimate for the roll-out value.

2.4. THEORETICAL GUARANTEES:

MÊLÉE is an instantiation of AGGREVATE (Ross & Bagnell, 2014) to meta-learning for contextual bandits. As such, it inherits the guarantees provided by AGGREVATE; for example: Theorem 1 (Thm 2.1 of Ross & Bagnell (2014) , adapted) After N rounds in the parameter-free setting, if a LEARN (line 16) is no-regret algorithm, then as N → ∞, with probability 1, it holds that J(π) ≤ J(π ) + 2T √ Kˆ class , where J(•) is the reward of the exploration policy, π is the average policy returned, and ˆ class is the average regression regret for each π n accurately predicting ρ.

This says that if we can achieve low regret at the problem of learning π on the training data it observes ("D" in MÊLÉE), then this translates into low regret in the contextual-bandit setting.

Furthermore, we provide a stylized analysis for the test-time behavior of MÊLÉE. In particular, we analyze MÊLÉE's test-time behavior in a special case: when the underlying learning algorithm is BANDITRON. BANDITRON is a variant of the multiclass Perceptron that operates under bandit feedback. Details of this analysis (and proofs, which directly follow the original BANDITRON analysis) are given in Appendix A; here we state the main result. Let

γ t = Pr[r t (π(f t , x t ) = 1)|x t ] -Pr[r t (f t (x t )) = 1|x t ] be the edge of π(f t , .) over f , and let Γ = 1 T T t=1 E 1

1+Kγt be an overall measure of the edge. (For instance: if π does nothing, then all γ t = 0 and Γ = 1.) Theorem 2 Assume that for the sequence of examples, (x 1 , r 1 ), (x 2 , r 2 ), . . . , (x T , r T ), we have, for all t, ||x t || ≤ 1. Let W be any matrix, let L be the cumulative hinge-loss of W , let µ be a uniform exploration probability, and let D = 2 ||W || 2 F be the complexity of W . Assume that Eγ t ≥ 0 for all t (that π never decreases the probability of a "correct" action). Then the number of mistakes M made by MÊLÉE with BANDITRON as POLOPT satisfies:

EM ≤ L + KµT + 3 max DΓ/µ, DT KΓµ + DLΓ/µ

(2) where the expectation is taken with respect to the randomness of the algorithm. This result is highly stylized and the assumption that Eγ t ≥ 0 is overly strong. It does, however, help us understand the behavior of MÊLÉE, qualitatively: First, the quantity that matters in Theorem 2, E t γ t is (in the 0/1 loss case) exactly what MÊLÉE is optimizing: the expected improvement for choosing an action against f t 's recommendation. Second, the benefit of using π within BANDITRON is a local benefit: because π is trained with expert rollouts, as discussed in § 2.4, the primary improvement in the analysis is to ensure that π does a better job predicting (in a single step) than f t does. An obvious open question is whether it is possible to base the analysis on the regret of π (rather than its error) and whether it is possible to extend beyond the simple BANDITRON setting.

3. EXPERIMENTAL SETUP AND RESULTS:

Our experimental setup operates as follows: Using a collection of synthetically generated classification problem, we train an exploration policy π using MÊLÉE (Alg 1). This exploration policy learns to explore on the basis of calibrated probabilistic predictions from f together with a predefined set of exploration features ( §3.1). Once π is learned and fixed, we follow the test-time behavior described in §2.2 on a set of 300 "simulated" contextual bandit problems, derived from standard classification tasks. In all cases, the underlying classifier f is a linear model trained with a policy optimizer that runs stochastic gradient descent under the hood.

We seek to answer two questions experimentally: (1) How does MÊLÉE compare empirically to alternative (hand-crafted) exploration strategies? (2) How important are the additional features used by the meta-learner in comparison to using calibrated probability predictions from f as features?

3.1. TRAINING DETAILS FOR THE EXPLORATION POLICY:

Exploration Features. In our experiments, the exploration policy is trained based on features Φ (Alg 1, line 12). These features are allowed to depend on the current classifier f t , and on any part of the history except the inputs x t in order to maintain task independence. We additionally ensure that its features are independent of the dimensionality of the inputs, so that π can generalize to datasets of arbitrary dimensions. The specific features we use are listed below; these are largely inspired by Konyushkova et al. (2017) but adapted and augmented to our setting. The features of f t that we use are: a) predicted probability p(a t |f t , x t ); b) entropy of the predicted probability distribution; c) a one-hot encoding for the predicted action f t (x t ). The features of h t-1 that we use are: a) current time step t; b) normalized counts for all previous actions predicted so far; c) average observed rewards for each action; d) empirical variance of the observed rewards for each action in the history. In our experiments, we found that it is essential to calibrate the predicted probabilities of the classifier f t . We use a very small held-out dataset, of size 30, to achieve this. We use Platt's scaling (Platt, 1999; Lin et al., 2007) method to calibrate the predicted probabilities. Platt's scaling works by fitting a logistic regression model to the classifier's predicted scores.

Training Datasets. In our experiments, we follow Konyushkova et al. (2017) (and also Peters et al. (2014) , in a different setting) and train the exploration policy π only on synthetic data. This is possible because the exploration policy π never makes use of x explicitly and instead only accesses it through f t 's behavior on it. We generate datasets with uniformly distributed class conditional distributions. The datasets are always two-dimensional. Details are in Appendix B.

Implementation Details. Our implementation is based on scikit-learn (Pedregosa et al., 2011) . We fix the training time exploration parameter µ to 0.1. We train the exploration policy π on 82 synthetic datasets each of size 3000 with uniform class conditional distributions, a total of 246k samples (Appendix B). We train π using a linear classifier Breiman (2001) and set the hyper-parameters for the learning rate, and data scaling methods using three-fold cross-validation on the whole metatraining dataset. For the classifier class F, we use a linear model trained with stochastic gradient descent. We standardize all features to zero mean and unit variance, or scale the features to lie between zero and one. To select between the two scaling methods, and tune the classifier's learning rate, we use three-fold cross-validation on a small fully supervised training set of size 30 samples. The same set is used to calibrate the predicted probabilities of f t .

3.2. EVALUATION TASKS AND METRICS:

Following Bietti et al. (2018) , we use a collection of 300 binary classification datasets from openml. org for evaluation; the precise list and download instructions is in Appendix C. These datasets cover a variety of different domains including text & image processing, medical diagnosis, and sensory data. We convert multi-class classification datasets into cost-sensitive classification problems by using a 0/1 encoding.Given these fully supervised cost-sensitive multi-class datasets, we simulate the contextual bandit setting by only revealing the reward for the selected actions. For evaluation, we use progressive validation (Blum et al., 1999) , which is exactly computing the reward of the algorithm. Specifically, to evaluate the performance of an exploration algorithm A on a dataset S of size n, we compute the progressive validation return G(A) as the average reward up to n: G(A) = 1 n n t=1 r t (a t ), where a t is the action chosen by the algorithm A and r t is the true reward vector.

Because our evaluation is over 300 datasets, we report aggregate results in two forms. The simpler one is Win/Loss Statistics: We compare two exploration methods on a given dataset by counting the number of statistically significant wins and losses. An exploration algorithm A wins over another algorithm B if the progressive validation return G(A) is statistically significantly larger than B's return G(B) at the 0.01 level using a paired sample t-test. We additionally report cumulative distributions of rewards for each algorithm. In particular, for a given relative reward value (x ∈ [0, 1]), the corresponding CDF value for a given algorithm is the fraction of datasets on which this algorithm achieved reward at least x. We compute relative reward by Min-Max normalization. Min-Max normalization linearly transforms reward y to x = y-min max-min , where min & max are the minimum & maximum rewards among all exploration algorithms. 

3.3. BASELINE EXPLORATION ALGORITHMS:

Our experiments aim to determine how MÊLÉE compares to other standard exploration strategies. In particular, we compare to:

-greedy: With probability , explore uniformly at random; with probability 1act greedily according to f t (Sutton, 1996) . Experimentally, we found = 0 optimal on average, consistent with the results of Bietti et al. (2018) . -decreasing: selects a random action with probabilities i , where i = 0 /t, 0 ∈]0, 1] and t is the index of the current round. In our experiments we set 0 = 0.1. (Sutton & Barto, 1998 ) Exponentiated Gradient -greedy: maintains a set of candidate values for -greedy exploration.

At each iteration, it runs a sampling procedure to select a new from a finite set of candidates. The probabilities associated with the candidates are initialized uniformly and updated with the Exponentiated Gradient (EG) algorithm. Following Li et al. (2010b) , we use the candidate set { i = 0.05×i + 0.01, i = 1, • • • , 10} for . LinUCB: Maintains confidence bounds for reward payoffs and selects actions with the highest confidence bound. It is impractical to run "as is" due to high-dimensional matrix inversions. We use diagonal approximation to the covariance when the dimensions exceeds 150. (Li et al., 2010a ) τ -first: Explore uniformly on the first τ fraction of the data; after that, act greedily. Cover: Maintains a uniform distribution over a fixed number of policies. The policies are used to approximate a covering distribution over policies that are good for both exploration and exploitation (Agarwal et al., 2014) . Cover Non-Uniform: similar to Cover, but reduces the level of exploration of Cover to be more competitive with the Greedy method. Cover-Nu doesn't add extra exploration beyond the actions chose by the covering policies (Bietti et al., 2018) .

In all cases, we select the best hyperparameters for each exploration algorithm following Bietti et al. (2018) . These hyperparameters are: the choice of in -greedy, τ in τ -first, the number of bags, and the tolerance ψ for Cover and Cover-NU. We set = 0.0, τ = 0.02, bag size = 16, and ψ = 0.1.

3.4. EXPERIMENTAL RESULTS:

The overall results are shown in Figure 1 . In the left-most figure, we see the CDFs for the different algorithms. To help read this, note that at x = 1.0, we see that MÊLÉE has a relative reward at least 1.0 on more than 40% of datasets, while -decreasing and -greedy achieve this on about 30% of datasets.

We find that the two strongest baselines are -decreasing and -greedy (better when reward differences are small, toward the left of the graph). The two curves for -decreasing and -greedy coincide. This happens because the exploration probability 0 for -decreasing decays rapidly approaching zero with a rate of 1 t , where t is the index of the current round. MÊLÉE outperforms the baselines in the "large reward" regimes (right of graph) but underperforms -decreasing and -greedy in low reward regimes (left of graph). In Figure 2 , we show statistically-significant win/loss differences for each of the algorithms. MÊLÉE is the only algorithm that always wins more than it loses against other algorithms. To understand more directly how MÊLÉE compares todecreasing, in the middle figure of Figure 1 , we show a scatter plot of rewards achieved by MÊLÉE (x-axis) and -decreasing (y-axis) on each of the 300 datasets, with statistically significant differences highlighted in red and insignificant differences in blue. Points below the diagonal line correspond to better performance by MÊLÉE (147 datasets) and points above to -decreasing (124 datasets). The remaining 29 had no significant difference.

MELEE:

In the right-most graph in Figure 1 , we show a representative example of learning curves for the various algorithms.

Here, we see that as more data becomes available, all the approaches improve (except τ -first, which has ceased to learn after 2% of the data).

Finally, we consider the effect that the additional features have on MÊLÉE's performance. In particular, we consider a version of MÊLÉE with all features (this is the version used in all other experiments) with an ablated version that only has access to the (calibrated) probabilities of each action from the underlying classifier f . The comparison is shown as a scatter plot in Figure 3 . Here, we can see that the full feature set does provide lift over just the calibrated probabilities, with a win-minus-loss improvement of 24. The field of meta-learning is based on the idea of replacing hand-engineered learning heuristics with heuristics learned from data. One of the most relevant settings for meta-learning to ours is active learning, in which one aims to learn a decision function to decide which examples, from a pool of unlabeled examples, should be labeled. Past approaches to meta-learning for active learning include reinforcement learning-based strategies (Woodward & Finn, 2017; Fang et al., 2017) , imitation learningbased strategies (Bachman et al., 2017) , and batch supervised learning-based strategies (Konyushkova et al., 2017) . Similar approaches have been used to learn heuristics for optimization (Li & Malik, 2016; Andrychowicz et al., 2016) , multiarm (noncontextual) bandits Maes et al. (2012) , and neural architecture search (Zoph & Le, 2016) , recently mostly based on (deep) reinforcement learning. While meta-learning for contextual bandits is prima facie most similar to meta-learning for active learning, there is a fundamental difference that makes it significantly more challenging: in active learning, the goal is to select as few examples as you can to learn, so by definition the horizon is short; in contextual bandits, learning to explore is fundamentally a long-horizon problem, because what matters is not immediate reward but long term learning.

4. RELATED WORK AND DISCUSSION:

In reinforcement learning, Gupta et al. (2018) investigated the task of meta-learning an exploration strategy for a distribution of related tasks by learning a latent exploration space. Similarly, Xu et al.

(2018) proposed a teacher-student approach for learning to do exploration in off-policy reinforcement learning. While these approaches are effective if the distribution of tasks is very similar and the state space is shared among different tasks, they fail to generalize when the tasks are different. Our approach targets an easier problem than exploration in full reinforcement learning environments, and can generalize well across a wide range of different tasks with completely unrelated features spaces.

There has also been a substantial amount of work on constructing "good" exploration policies, in problems of varying complexity: traditional bandit settings (Karnin & Anava, 2016), contextual bandits (Féraud et al., 2016) and reinforcement learning (Osband et al., 2016) . In both bandit settings, most of this work has focused on the learning theory aspect of exploration: what exploration distributions guarantee that learning will succeed (with high probability)? MÊLÉE, lacks such guarantees: in particular, if the data distribution of the observed learning contexts (φ(f t )) in some test problem differs substantially from that on which MÊLÉE was trained, we can say nothing about the quality of the learned exploration. Nevertheless, despite fairly substantial distribution mismatch (synthetic → real-world), MÊLÉE works well in practice, and our stylized theory ( §2.4) suggests that there may be an interesting avenue for developing strong theoretical results for contextual bandit learning with learned exploration policies, and perhaps other meta-learning problems.

Supplementary Material For: Meta-Learning for Contextual Bandit Exploration A STYLIZED TEST-TIME ANALYSIS FOR BANDITRON: DETAILS:

The BANDITRONMÊLÉE algorithm is specified in Alg 2. The is exactly the same as the typical test time behavior, except it uses a BANDITRON-type strategy for learning the underlying classifier f in the place of POLOPT. POLICYELIMINATIONMETA takes as arguments: π (the learned exploration policy) and µ ∈ (0, 1/(2K)) an added uniform exploration parameter. The BANDITRON learns a linear multi-class classifier parameterized by a weight matrix of size K×D, where D is the input dimensionality. The BANDITRON assumes a pure multi-class setting in which the reward for one ("correct") action is 1 and the reward for all other actions is zero.

At each round t, a prediction ât is made according to f t (summarized by W t ). We then define an exploration distribution that "most of the time" acts according to π(f t , .), but smooths each action with µ probability. The chosen action a t is sampled from this distribution and a binary reward is observed. The weights of the BANDITRON are updated according to the BANDITRON update rule using Ũ t .

Algorithm 2 BANDITRONMÊLÉE (g, µ) update W t+1 = W t + Ũ t 10: end for

1: initialize W 1 = 0 ∈ R K ×

The only difference between BANDITRONMÊLÉE and the original BANDITRON is the introduction of π in the sampling distribution. The original algorithm achieves the following mistake bound shown below, which depends on the notion of multi-class hinge-loss. In particular, the hinge-loss of W on (x, r) is (W, (x, r)) = max a =a max 0, 1 -(W x) a + (W x) a , where a is the a for which r(a) = 1. The overall hinge-loss L is the sum of over the sequence of examples.

Theorem 3 (Thm. 1 and Corr. 2 of Kakade et al. (2008) ) Assume that for the sequence of examples, (x 1 , r 1 ), (x 2 , r 2 ), . . . , (x T , r T ), we have, for all t, ||x t || ≤ 1. Let W be any matrix, let L be the cumulative hinge-loss of W , and let D = 2 ||W || We can prove an analogous result for BANDITRONMÊLÉE. The key quantity that will control how much π improves the execution of BANDITRONMÊLÉE is how much π improves on f t when f t is wrong. In particular, let γ t = Pr[r t (π(f t , x t ) = 1)|x t ] -Pr[r t (f t (x t )) = 1|x t ] be the edge of π(f t , .) over f , and let Γ = 1 T T t=1 E 1 1+Kγt be an overall measure of the edge. (If π does nothing, then all γ t = 0 and Γ = 1.) Given this quantity, we can prove the following Theorem 2.

Proof: [sketch] The proof is a small modification of the original proof of Theorem 3. The only change is that in the original proof, the following bound is used: E t || Ũ t || 2 /||x t || 2 = 1 + 1/µ ≤ 2/µ.

:

Code release: the code is available online https://www.dropbox.com/sh/dc3v8po5cbu8zaw/ AACu1f_4c4wIZxD1e7W0KVZ0a?dl=0

In other work on meta-learning, such problems are often cast as full reinforcement-learning problems. We opt for imitation learning instead because it is computationally attractive and effective when a simulator exists.

Because π needs to learn to be task independent, we found that if fts were uncalibrated, it was very difficult for π to generalize well to unseen tasks. In our experiments we use only 30 fully labeled examples, but alternative approaches to calibrating ft that do not require this data would be ideal.

Figures and Tables:

MÊLÉE (supervised training sets {S m }, hypothesis class F, exploration rate µ = 0.1, number of validation examples N Val = 30), feature extractor Φ 1: for round n = 1, 2, . . . , N do 2: initialize meta-dataset D = {} and choose dataset S at random from {S m } 3: partition and permute S randomly into train Tr and validation Val where |Val| = N Val 4: set history h 0 = {} 5:

Figure 1: Comparison of algorithms on 300 classification problems. (Left) Comparison of all exploration algorithms using the empirical cumulative distribution function of the relative progressive validation return G (upper-right is optimal). The curves for -decreasing & -greedy coincide. (Middle) Comparison of MÊLÉE to the second best performing exploration algorithm ( -decreasing), every data point represents one of the 300 datasets, x-axis shows the reward of G(MÊLÉE), y-axis show the reward of G( -decreasing), and red dots represent statistically significant runs. (Right) A representative learning curve on dataset #1144.

Figure 2: Win statistics: each (row, column) entry shows the number of times the row algorithm won against the column, minus the number of losses.

Figure 3: Comparison of trainingMÊLÉE with all the features ( § 3.1, yaxis) vs training using only the calibrated prediction probabilities (x-axis). MÊLÉE gets an additional leverage when using all the features.

D 2: for rounds t = 1 . . . T : do3: observe x t ∈ R D 4: compute ât = f t (x t ) = argmax k∈K W t x t k 5: define Q µ (a) = µ + (1 -Kµ)1[a = π(W t , x t )] 6: sample a t ∼ Q µ

r t (a t ) ∈ {0, 1} 8: define Ũ t ∈ R K × D as:

be the complexity of W . The number of mistakes M made by the BANDITRON satisfiesEM ≤ L + KµT + 3 max D µ , DT Kµ + DL/µ (3)where the expectation is taken with respect to the randomness of the algorithm. Furthermore, in a low noise setting (there exists W with fixed complexity d and loss L ≤ O( √ DKT )), then by setting µ = D/(T K), we obtain EM ≤ O( √ KDT ).

Peer review (iclr2019):
 This paper investigates a meta-learning approach for the contextual bandit problem. The goal is to learn a generic exploration policy from datasets, and then to apply the exploration policy to contextual bandit tasks. The authors have adapted an algorithm proposed for imitation learning (Ross & Bagnell 2014) to their setting. Some theoretical guarantees straightforwardly extracted from (Ross & Bagnell 2014) and from (Kakade et al 2008) are presented. Experiments are done on 300 supervised datasets. Major concerns: 1 This paper investigates a problem that does not correspond to the real problem: how to take advantage of a plenty of logs generated by a known stochastic policy (or worst unknown deterministic policy) for the same (or a close) contextual bandit task? Most of companies have this problem. I do not know a single use case, in which we have some full information datasets, which are representative of contextual bandit tasks to be performed. If the full information datasets does not correspond to the contextual bandit tasks, it is not possible to learn something useful for the contextual bandit task. 2 The experimental validation is not convincing. The experiments are done on datasets, which are mostly binary classification datasets. In this case, the exploration task is easy. May be it is the reason why the exploration parameter .mu or .epsilon = 0 provides the best results for MELEE or .epsilon-greedy? The baselines are not strong. The only tested contextual bandit algorithm is LinUCB. However a diagonal approximation of the covariance matrix is used when the dimension exceeds 150. In this case LinUCB is not efficient. There are a lot of contextual bandit algorithms that scale with the dimension. 3 The theoretical guarantees are not convincing. The result of Theorem 1 is a weak result. A linear regret against the expected reward of the best policy is usually considered as a loosely result. Theorem 2 shows that there is no theoretical gain of the use of the proposed algorithm: the upper bound of the expected number of mistakes obtained when Banditron is used in MELEE is upper than the one of Banditron alone. Minor concerns: The algorithms are not well written. POLOPT function has sometimes one parameter, sometimes two and sometimes three parameters. The algorithm 1 is described in section 2, while one of the inputs of the algorithm 1 (feature extractor function) is described in section 3.1. The algorithm 1 seems to return all the N exploration policies. The choice of the returned policy has to be described. In contextual bandits, the exploration policy is not handcrafted. The contextual bandit algorithms are designed to be optimal or near optimal in worst case: they are generic algorithms.