ROI Maximization in Stochastic Online Decision-Making
Year: 2022

Abstract:
We introduce a novel theoretical framework for Return On Investment (ROI) maximization in repeated decision-making. Our setting is motivated by the use case of companies that regularly receive proposals for technological innovations and want to quickly decide whether they are worth implementing. We design an algorithm for learning ROI-maximizing decision-making policies over a sequence of innovation proposals. Our algorithm provably converges to an optimal policy in class Π at a rate of order min { 1/(N∆), N−1/3}, where N is the number of innovations and ∆ is the suboptimality gap in Π. A significant hurdle of our formulation, which sets it aside from other online learning problems such as bandits, is that running a policy does not provide an unbiased estimate of its performance.

text: { 1/(N∆2), N−1/3}, where N is the number
of innovations and ∆ is the suboptimality gap in Π. A significant hurdle of our formulation, which sets it aside from other online learning problems such as bandits, is that running a policy does not provide an unbiased estimate of its performance.

heading: 1 Introduction
text: Often, companies have to make yes/no decisions, such as whether to adopt a new technology or retire an old product. However, finding out the best option in all circumstances could mean spending too much time or money in the evaluation process. If the decisions to make are many, one could be better off making more of them quickly and inexpensively, provided that these decisions have an overall positive effect. In this paper, we investigate the problem of determining a decision policy to balance the reward over cost ratio optimally (i.e., to maximize the return on investment).
A motivating example. Consider a technology company that keeps testing innovations to increase some chosen metric (e.g., benefits, gross revenue, revenue excluding the traffic acquisition cost). Before deploying an innovation, the company wants to figure out whether it is profitable. As long as each innovation can be tested on i.i.d. samples of users, the company can perform randomized tests and make statistically sound decisions. However, there is an incentive to make these tests run as quickly as possible because, for example, the testing process is expensive. Another reason could be that keeping a team on a project that has negative, neutral, or even borderline positive potential prevents it from testing other ideas that might lead to a significantly better improvement. In other words, it is crucial to learn when to drop barely positive innovations in favor of highly positive ones, so to increase the overall flow of improvement over time (i.e., the ROI of the tests).
More generally, our framework describes problems where an agent faces a sequence of decision tasks consisting of either accepting or rejecting an innovation. Before making each decision, the agent can invest resources into reducing the uncertainty on the value brought by the innovation. The global objective is to maximize the total ROI. Namely, the ratio between the total value accumulated by accepting innovations and the total cost. For an in-depth discussion on alternative goals, we refer the reader to the Supplementary Material (Section D).
35th Conference on Neural Information Processing Systems (NeurIPS 2021).
The model. Each task n in the sequence is associated with a pair (µn, Dn) that the learner can never directly observe.
• µn is a random variable representing the (possibly negative) true value of the n-th innovation. • Dn is a probability distribution over the real numbers with expectation µn, modeling the
feedback on the n-th innovation that the learner can gather from testing (see below).
During the n-th task, the learner can draw arbitrarily many i.i.d. samples Xn,1, Xn,2, . . . from Dn, accumulating information on the unknown value µn of the innovation currently being tested. After stopping drawing samples, the learner can decide to either accept the innovation, earning µn as a reward, or reject it and gain nothing instead. We measure the agent performance during N tasks as the (expected) total amount of value accumulated by accepting innovations µn divided by the (expected) total number of samples requested throughout all tasks. In formulas, the ROI of a strategy is then∑N
n=1 E [ µn · I{µn is accepted} ]∑N n=1 E [ number of samples requested during the n-th task
] In Section 3 we present this setting in more detail and introduce the relevant notation.
I.I.D. assumption. We assume that the value µn of the n-th innovation is drawn i.i.d. from an unknown and fixed distribution. This assumption is meaningful if past decisions do not influence future innovations whose global quality remains stable over time. In particular, it applies whenever innovations can progress in many orthogonal directions, each yielding a similar added value (e.g., when different teams within the same company test improvements relative to individual aspects of the company). If both the state of the agent and that of the environment evolve, but the ratio of good versus bad innovations remains essentially the same, then this i.i.d. assumption is still justified. In other words, it is not necessarily the absolute quality of the innovations that has to remain stationary, but rather the relative added value of the innovations given the current state of the system. This case is frequent in practice, especially when a system is close to its technological limit. Last but not least, algorithms designed under stochastic assumptions often perform surprisingly well in practice, even if i.i.d. assumptions are not fully satisfied or simply hard to check.
A baseline strategy and policy classes. A natural, yet suboptimal, approach for deciding if an innovation is worth accepting is to gather samples sequentially, stopping as soon as the absolute value of their running average surpasses a threshold, and then accepting the innovation if and only if the average is positive. The major drawback of this approach is that the value µn of an innovation n could be arbitrarily close to zero. In this case, the number of samples needed to reliably determine its sign (which is of order 1/µ2n) would become prohibitively large. This would result is a massive time investment for an innovation whose return is negligible at best. In hindsight, it would have been better to reject the innovation early and move on to the next task. For this reason, testing processes in practice needs hard termination rules of the form: if after drawing a certain number of samples no confident decision can be taken, then terminate the testing process rejecting the current innovation. Denote by τ this capped early stopping rule and by accept the accept/reject decision rule that comes with it. We say that the pair π = (τ, accept) is a policy because it fully characterize the decision-making process for an innovation. Policies defined by capped early stopping rules (see (4) for a concrete example) are of great practical importance (Johari et al., 2017; Kohavi et al., 2013). However, policies can be defined more generally by any reasonable stopping rule and decision function. Given a (possibly infinite) set of policies, and assuming that µ1, µ2, . . . are drawn i.i.d. from some unknown but fixed distribution, the goal is to learn efficiently, at the lowest cost, the best policy π? in the set with respect to a sensible metric. Competing against fixed policy classes is a common modeling choice that allows to express the intrinsic constraints that are imposed by the nature of the decision-making problem. For example, even if some policies outside of the class could theoretically yield better performance, they might not be implementable because of time, budget, fairness, or technology constraints.
Challenges. One of the biggest challenges arising in our framework is that running a decisionmaking policy generates a collection of samples that —in general— cannot be used to form an unbiased estimate of the policy reward (see the impossibility result in Section E of the Supplementary Material). The presence of this bias is a significant departure from settings like multiarmed and firing bandits (Auer et al., 2002; Jain and Jamieson, 2018), where the learner observes an unbiased sample of the target quantity at the end of every round (see the next section for additional details). Moreover, contrary to standard online learning problems, the relevant performance measure is neither additive in
the number of innovations nor in the number of samples per innovation. Therefore, algorithms have to be analyzed globally, and bandit-like techniques —in which the regret is additive over rounds— cannot be directly applied. We argue that these technical difficulties are a worthy price to pay in order to define a plausible setting, applicable to real-life scenarios.
Main contributions. The first contribution of this paper is providing a mathematical formalization of our ROI maximization setting for repeated decision making (Section 3). We then design an algorithm called Capped Policy Elimination (Algorithm 1, CAPE) that applies to finite policy classes (Section 4). We prove that CAPE converges to the optimal policy at rate 1/(∆2N), where N is the number of tasks and ∆ is the unknown gap between the performance of the two best policies, and at rate N−1/3 when ∆ is small (Theorem 1) . In Section 5 we tackle the challenging problem of infinitely large policy classes. For this setting, we design a preprocessing step (Algorithm 2, ESC) that leads to the ESC-CAPE algorithm. We prove that this algorithm converges to the optimal policy in an infinite set at a rate of N−1/3 (Theorem 4).
Limitations. Although we do not investigate lower bounds in this paper, we conjecture that our N−1/3 convergence rate it is optimal due to similarities with bandits with weakly observable feedback graphs (see Section 4, “Divided we fall”). Another limitation of our theory is that it only applies to i.i.d. sequences of values µn. It would be interesting to extend our analysis to distributions of µn that evolve over time. These two intriguing problems are left open for future research.

heading: 2 Related Work
text: Return on Investment (ROI) was developed and popularized by Donaldson Brown in the early Nineties (Flesher and Previts, 2013) and it is still considered an extremely valuable metric by the overwhelming majority of marketing managers (Farris et al., 2010). Beyond economics, mathematics, and computer science, ROI finds applications in other fields, such as cognitive science and psychology (Chabris et al., 2009). Despite this, to the best of our knowledge, no theoretical online learning framework has been developed specifically for ROI maximization. However, our novel formalization of this sequential decision problem does share some similarities with other known online learning settings. In this section, we review the relevant literature regarding these settings and stress the differences with ours.
Prophet inequalities and Pandora’s box. In prophet inequalities (Lucier, 2017; Correa et al., 2019; Alaei et al., 2012), an agent observes sequentially (usually non-negative) random variables Z1, . . . , Zn and decides to stop at some time τ ; the reward is then Zτ . Variants include the possibility of choosing more than one random variable (in which case the reward is some function of the selected random variables), and the possibility to go back in time (to some extent). The Pandora’s box problem is slightly different (Weitzman, 1979; Kleinberg et al., 2016; Esfandiari et al., 2019); in its original formulation, the agent can pay a cost cn ≥ 0 to observe any Zn. After stopping exploring, the agent’s final utility is the maximum of the observed Zn’s minus the cumulative cost (or, in other variants, some function of these). Similarly to the (general) prophet inequality, the agent in our sequential problem faces random variables (Zn = µn in our notation) and sequentially selects any number of them (possibly with negative values) without the possibility to go back in time and change past decisions. The significant difference is that the agent in our setting never observes the value of µn. In Pandora’s box, the agent can see this value by paying some price (that approximately scales as 1/ε2 where ε is the required precision). Finally, the global reward is the cumulative sum (as in prophets) and not the maximum (as in Pandora’s box) of the selected variables, normalized by the total cost (as in Pandora’s box, but our normalization is multiplicative instead of additive, as it represents a ROI).
Multi-armed bandits. If we think of the set of all policies used by the agent to determine whether or not to accept innovations as arms, our setting becomes somewhat reminiscent of multi-armed bandits (Slivkins, 2019; Bubeck and Cesa-Bianchi, 2012; Rosenberg et al., 2007). However, there are several notable differences between these two problems. In stochastic bandits, the agent observes an unbiased estimate of the expected reward of each pulled arm. In our setting, the agent not only does not see it directly, but it is mathematically impossible to define such an estimator solely with the feedback received (see the impossibility result in Section E of the Supplementary Material). Hence, off-the-shelf bandit algorithms cannot be run to solve our problem. In addition, the objective in bandits is to maximize the cumulative reward, which is additive over time, while the ROI is not. Thus, it is unclear how formal guarantees for bandit algorithms would translate to our problem.
We could also see firing bandits (Jain and Jamieson, 2018) as a variant of our problem, where µn belongs to [0, 1], Dn are Bernoulli distribution with parameter µn, and policies have a specific form that allows to easily define unbiased estimates of their rewards (which, we reiterate, is not possible in our setting in general). Furthermore, in firing bandits, it is possible to go back and forth in time, sampling from any of the past distributions Dn and gathering any number of samples from it. This is a reasonable assumption for the original motivations of firing bandits because the authors thought of µn as the value of a project in a crowdfunding platform, and, in their setting, drawing samples from Dn corresponds to displaying projects on web pages. However, in our setting, µn represents the theoretical increment (or decrement) of a company’s profit through a given innovation, and it is unlikely that a company would show new interest in investing in a technology that has been tested before and did not prove to be useful (a killed project is seldom re-launched). Hence, when the sampling of Dn stops, an irrevocable decision is made. After that, the learner cannot draw any more samples in the future. Finally, as in multi-armed bandits, the performance criterion in firing bandits is the cumulative reward and not the global ROI.
Another online problem that shares some similarities with ours is bandits with knapsacks (Badanidiyuru et al., 2018). In this problem, playing an arm consumes one unit of time together with some other resources, and the learner receives an unbiased estimate of its reward as feedback. The process ends as soon as time or any one of the other resources is exhausted. As usual, the goal is to maximize the cumulative regret. As it turns out, we can also think of our problem as a budgeted problem. In this restatement, there is a budget of T samples. The repeated decision-making process proceeds as before, but it stops as soon as the learner has drawn a total of T samples across all decision tasks. The goal is again to maximize the total expected reward of accepted innovations divided by T (see Section D of the Supplementary Material for more details on the reduction). As per the other bandit problems, there are two crucial differences. First, running a policy does not reveal an unbiased estimate of its reward. Second, our objective is different, and regret bounds do not directly imply convergence to optimal ROI. For other examples of budget-constrained bandit settings, see also (Cayci et al., 2020, 2019).
Repeated A/B testing. We can view our problem as a framework for repeated A/B testing (Tukey, 1953; Genovese et al., 2006; Foster and Stine, 2008; Heesen and Janssen, 2016; Javanmard et al., 2018; Azevedo et al., 2018; Li and Barber, 2019; Schmit et al., 2019; Xu et al., 2021; Johari et al., 2021), in which assessing the value of an innovation corresponds to performing an A/B test, and the goal is maximizing the ROI. A popular metric to optimize sequential A/B tests is the so-called false discovery rate (FDR) —see (Ramdas et al., 2017; Yang et al., 2017) and references therein. Roughly speaking, the FDR is the ratio of accepted µn that are negative over the total number of accepted µn (or more generally, the number of incorrectly accepted tests over the total number if the metric used at each test changes with time). This, unfortunately, disregards the relative values of tests µn that must be taken into account when optimizing a single metric (Chen and Kasiviswanathan, 2020; Robertson and Wason, 2018). Indeed, the effect of many even slightly negative accepted tests could be overcome by a few largely positive ones. For instance, assume that the samples Xn,i of any distribution Dn belong to {−1, 1}, and that their expected value µn is uniformly distributed on {−ε, ε}. To control the FDR, each A/B test should be run for approximately 1/ε2 times, yielding a ratio of the average value of an accepted test to the number of samples of order ε3. A better strategy, using just one sample from each A/B test, is simply to accept µn if and only if the first sample is positive. Direct computations show that this policy, which fits our setting, achieves a significantly better performance of order ε.
Some other A/B testing settings are more closely related to ours, but make stronger additional assumptions or suppose preliminary knowledge: for example, smoothness assumptions can be made on both Dn and the distributions of µn (Azevedo et al., 2018), or the distribution of µn is known, and the distribution of samples belongs to a single parameter exponential family, also known beforehand (Schmit et al., 2019).
A related topic that sits in between multi-armed bandits and repeated A/B testing is best-arm identification—see, e.g., the recent paper (Garivier and Kaufmann, 2021) and references therein— where the learner has to minimize the number of observations needed to select a (near)-optimal arm.
Rational metareasoning. Our setting is loosely related to the AI field of meta-reasoning (Griffiths et al., 2019; Hay et al., 2012). In a metalevel decision problem, determining the utility (or reward) of
a given action is computationally intractable. Instead, the learner can run a simulation, investing a computational cost to gather information about this hidden value. The high-level idea is then to learn which actions to simulate. After running some simulations, the learner picks an action to play, gains the corresponding (hidden) reward, and the state of the system changes. In rational meta-reasoning, the performance measure is the value of computation (VOC): the difference between the increment in expected utility gained by executing a simulation and the cost incurred by doing so. This setting is not directly comparable to ours for two reasons. First, the performance measure is different, and the additive nature of the difference that defines the VOC gives no guarantees on our multiplicative notion of ROI. Second, in this problem, one can pick which actions to simulate, while in our settings, innovations come independently of the learner, who has to evaluate them in that order.

heading: 3 Setting and Notation
text: In this section, we formally introduce the repeated decision-making protocol for an agent whose goal is to maximize the total return on investment in a sequence of decision tasks.
The only two choices that an agent makes in a decision task are when to stop gathering information on the current innovation and whether or not to accept the innovation based on this information. In other words, the behavior of the agent during each task is fully characterized by the choice of a pair π = (τ, accept) that we call a (decision-making) policy (for the interested reader, Section A of the Supplementary Material contains a short mathematical discussion on policies), where:
• τ(x), called duration, maps a sequence of observations x = (x1, x2, . . .) to an integer d (the no. of observations after which the learner stops gathering info on the current innovation);
• accept(d,x), called decision, maps the firs d observations of a sequence x = (x1, x2, . . .) to a boolean value in {0, 1} (where 1 represents accepting the current innovation).
An instance of our repeated decision-making problem is therefore determined by a set of admissible policies Π = {πk}k∈K = {(τk, accept)}k∈K (with K finite or countable) and a distribution D on [−1, 1], modelling the value of innovations.1 Naturally, the former is known beforehand but the latter is unknown and should be learned.
For a fixed choice of Π and D, the protocol is formally described below. In each decision task n:
1. the value µn of the current innovation is drawn i.i.d. according to D; 2. Xn is a sequence of i.i.d. (given µn) observations with Xn,i = ±1 and E[Xn,i | µn] = µn; 3. the agent picks kn ∈ K or, equivalently, a policy πkn = (τkn , accept) ∈ Π; 4. the agent draws the first dn = τkn(Xn) samples
2 of the sequence of observations Xn; 5. on the basis of these sequential observations, the agent makes the decision accept ( dn,Xn ) .
Crucially, µn is never revealed to the learner. We say that the agent runs a policy πk = (τk, accept) (on a value µn) when steps 4–5 occur (with kn ← k). We also say that they accept (resp., rejects) µn if their decision at step 5 is equal to 1 (resp., 0). Moreover, we say that the reward obtained and the cost3 paid by running a policy πk = (τk, accept) on a value µn are, respectively,
reward(πk, µn) = µn accept ( τk(Xn),Xn ) ∈ {µn, 0} cost(πk, µn) = τk(Xn) ∈ N (1)
The objective of the agent is to converge to the highest ROI of a policy in Π, i.e., to guarantee that
RN = sup k∈K
∑N n=1 E [ reward(πk, µn) ]∑N m=1 E [ cost(πk, µm) ] − ∑Nn=1 E[reward(πkn , µn)]∑N m=1 E [ cost(πkm , µm)
] → 0 as N →∞ (2) where the expectations are taken with respect to µn, Xn, and (possibly) the random choices of kn.
1We assume that the values of the innovations and the learner’s observations belong to [−1, 1] and {−1, 1} respectively. We do this merely for the sake of readability (to avoid carrying over awkward constants or distributions Dn). With a standard argument, both [−1, 1] and {−1, 1} can be extended to arbitrary codomains straightforwardly under a mild assumption of subgaussianity.
2Given µn, the random variable dn is a stopping time w.r.t. the natural filtration associated to Xn. 3We define the cost as the duration τk(Xn) of a run. Following our exact proofs, one can see that everything remains true if we define the cost in terms of any increasing function of the duration. This puts no meaningful restrictions on cost functions.
To further lighten notations, we denote the expected reward, cost, and ROI of a policy π by reward(π) = E [ reward(π, µn) ] , cost(π) = E [ cost(π, µn) ] , ROI(π) = reward(π)/cost(π) (3)
respectively and we say that πk? is an optimal policy if k? ∈ argmaxk∈KROI(πk). Note that reward(π) and cost(π) do not depend on n because µn is drawn i.i.d. according to µ.
For each policy (τ, accept) ∈ Π and all tasks n, we allow the agent to reject the value µn regardless of the outcome of the sampling. Formally, the agent can always run the policy (τ, 0), where the second component of the pair is the decision identically equal to zero (i.e., the rule “always reject”).
We also allow the agent to draw arbitrarily many extra samples in addition to the number τ(Xn) that they would otherwise draw when running a policy (τ, accept) ∈ Π on a value µn, provided that these additional samples are not taken into account in the decision to either accept or reject µn. Formally, the agent can always draw τ(Xn) + k many samples (for any k ∈ N) before making the decision accept ( τ(Xn),Xn ) , where we stress that the first argument of the decision function accept is τ(Xn) and not τ(Xn) + k. Oversampling this way worsens the objective and might seem utterly counterproductive, but it will be crucial for recovering unbiased estimates of µn.

heading: 4 Competing Against K policies (CAPE)
text: As we mentioned in the introduction, in practice the duration of a decision task is defined by a capped early-stopping rule —e.g., drawing samples until 0 falls outside of a confidence interval around the empirical average, or a maximum number of draws has been reached. More precisely, if N tasks have to be performed, one could consider the natural policy class {(τk, accept)}k∈{1,...,K} given by
τk(x) = min ( k, inf {d ∈ N : |xd| ≥ αd} ) and accept(d,x) = I {xd ≥ αd} (4)
where xd = (1/d) ∑d i=1 xi is the average of the first d elements of the sequence x = (x1, x2, . . .)
and αd = c √
(1/d) ln(KN/δ), for some c > 0 and δ ∈ (0, 1). While in this example policies are based on an Hoeffding concentration rule, in principle the learner is free to follow any scheme. Thus, we now generalize this notion and present an algorithm with provable guarantees against these finite families of policies.
Finite sets of policies. In this section, we focus on finite sets of K policies Π = {πk}k∈{1,...,K} = {(τk, accept)}k∈{1,...,K} where accept is an arbitrary decision and τ1, . . . , τK is any sequence of bounded durations (say, τk ≤ k for all k).4 For the sake of convenience, we assume the durations are sorted by index (τk ≤ τh if k ≤ h), so that τ1 is the shortest and τK is the longest.
Divided we fall. A common strategy in online learning problems with limited feedback is explorethen-commit (ETC). ETC consists of two phases. In the first phase (explore), each action is played for the same amount of rounds, collecting this way i.i.d. samples of all rewards. In the subsequent commit phase, the arm with the best empirical observations is played consistently. Being very easy to execute, this strategy is popular in practice, but unfortunately, it is theoretically suboptimal in some applications. A better approach is performing action elimination. In a typical implementation of this strategy, all actions in a set are played with a round-robin schedule, collecting i.i.d. samples of their rewards. At the end of each cycle, all actions that are deemed suboptimal are removed from the set, and a new cycle begins. Neither one of these strategies can be applied directly because running a policy in our setting does not return an unbiased estimate of its reward (for a quick proof of this simple result, see Section E in the Supplementary Material). However, it turns out that we can get an i.i.d. estimate of a policy π by playing a different policy π′. Namely, one that draws more samples than π. This is reminiscent of bandits with a weakly observable feedback graph, a related problem for which the time-averaged regret over T rounds vanishes at a T−1/3 rate (Alon et al., 2015). Albeit none of these three techniques works on its own, suitably interweaving all of them does.
United we stand. With this in mind, we now present our simple and efficient algorithm (Algorithm 1, CAPE) whose ROI converges (with high probability) to the best one in a finite family of policies. We will later discuss how to extend the analysis even further, including countable families of policies. Our algorithm performs policy elimination (lines 1–5) for a certain number of tasks
4We chose τk ≤ k for the sake of concreteness. All our results can be straightforwardly extended to arbitrary τk ≤ Dk by simply assuming without loss of generality that k 7→ Dk is monotone and replacing k with Dk.
(line 1) or until a single policy is left (line 6). After that, it runs the best policy left in the set (line 7), breaking ties arbitrarily,5 for all remaining tasks. During each policy elimination step, the algorithm oversamples (line 2) by drawing twice as many samples as it would suffice to take its decision accept ( τmax(Cn)(Xn),Xn ) (at line 3). These extra samples are used to compute rough estimates of rewards and costs of all potentially optimal policies and more specifically to build unbiased estimates of these rewards. The test at line 4 has the only purpose of ensuring that the denominators ĉ−n (k) at line 5 are bounded away from zero so that all quantities are well-defined.
Algorithm 1: Capped Policy Elimination (CAPE) Input: finite policy set Π, number of tasks N , confidence parameter δ, exploration cap Nex Initialization: let C1 ← {1, . . . ,K} be the set of indices of all currently optimal candidates
1 for task n = 1, . . . , Nex do 2 draw the first 2max(Cn) samples Xn,1, . . . , Xn,2max(Cn) of Xn 3 make the decision accept ( τmax(Cn)(Xn),Xn ) 4 if n ≥ 2K2 ln(4KNex/δ) then let Cn+1 ← Cn \ C ′n, where
5 C ′n = { k ∈ Cn : ( r̂+n (k) ≥ 0 and r̂+n (k)/ĉ−n (k) < r̂−n (j)/ĉ+n (j), for some j ∈ Cn ) or ( r̂+n (k) < 0 and r̂ + n (k)/ĉ + n (k) < r̂ − n (j)/ĉ − n (j), for some j ∈ Cn
)} r̂±n (k) = 1
n n∑ m=1 max(Cm)∑ i=1 Xm,max(Cm)+i max(Cm) accept ( τk(Xm),Xm ) ± √ 2 n ln 4KNex δ (5)
ĉ±n (k) = 1
n n∑ m=1 τk(Xm)± (k − 1) √ 1 2n ln 4KNex δ
(6)
6 if |Cn+1| = 1 then let r̂±Nex(k)← r̂ ± n (k), ĉ ± Nex (k)← ĉ±n (k), CNex+1 ← Cn+1, break 7 run policy πk′ for all remaining tasks, where
k′ ∈  argmax k∈CNex+1 ( r̂+Nex(k)/ĉ − Nex (k) ) if r̂+Nex(k) ≥ 0 for some k ∈ CNex+1
argmax k∈CNex+1
( r̂+Nex(k)/ĉ + Nex (k) ) if r̂+Nex(k) < 0 for all k ∈ CNex+1 (7)
As usual in online learning, the gap in performance between optimal and sub-optimal policies is a complexity parameter. We define it as ∆ = mink 6=k? ( ROI(πk?)− ROI(πk) ) , where we recall that k? ∈ argmaxk ROI(πk) is the index of an optimal policy. Conventionally, we set 1/0 =∞.
Theorem 1. If Π is a finite set of K policies, then the ROI of Algorithm 1 run for N tasks with exploration cap Nex = ⌈ N2/3 ⌉ and confidence parameter δ ∈ (0, 1) converges to the optimal ROI(πk?), with probability at least 1− δ, at a rate
RN = Õ ( min ( K3
∆2N , K N1/3 )) as soon as N ≥ K3 (where the Õ notation hides only logarithmic terms, including a log(1/δ) term).
Proof sketch. This theorem relies on four technical lemmas (Lemmas 5-8) whose proofs are deferred to Section B of the Supplementary Material.
With a concentration argument (Lemma 5), we leverage the definitions of r̂±n (k), ĉ ± n (k) and the i.i.d. assumptions on the samples Xn,i to show that, with probability at least 1− δ, the event
r̂−n (k) ≤ reward(πk) ≤ r̂+n (k) and ĉ−n (k) ≤ cost(πk) ≤ ĉ+n (k) (8)
5More precisely, ties should be broken in a measurable way, e.g., uniformly at random. We do not insist on this point here, but the interested reader might see (Cesari and Colomboni, 2021, Section 2.4) for a more thorough discussion on this topic.
occurs simultaneously for all n ≤ Nex and all k ≤ max(Cn). For the rewards, the key is oversampling, because accept ( τk(Xm),Xm ) in eq. (5) depends only on the first k ≤ max(Cm) samples of Xm and is therefore independent of Xm,max(Cm)+i for all i. Assume now that (8) holds.
If ∆ > 0 (i.e., if there is a unique optimal policy), we then obtain (Lemma 6) that suboptimal policies are eliminated after at most N ′ex tasks, where N ′ ex ≤ 288K2 ln(4KNex/δ)/∆2 + 1. To prove it we
show that a confidence interval for ROI(πk) = reward(πk)/cost(πk) is given by[ r̂−n (k)
ĉ+n (k) I { r̂+n (k) ≥ 0 } + r̂−n (k) ĉ−n (k) I { r̂+n (k) < 0 } , r̂+n (k) ĉ−n (k) I { r̂+n (k) ≥ 0 } + r̂+n (k) ĉ+n (k) I { r̂+n (k) < 0 }] we upper bound its length, and we compute an N ′ex such that this upper bound is smaller than ∆/2.
Afterwards, we analyze separately the case in which the test at line 6 is true for some task N ′ex ≤ Nex and its complement (i.e., when the test is always false).
In the first case, by (8) there exists a unique optimal policy, i.e., we have that ∆ > 0. This is where the policy-elimination analysis comes into play. We can apply the bound above on N ′ex, obtaining a deterministic upper bound N ′′ex on the number N ′ ex of tasks needed to identify the optimal policy. Using this upper bound, writing the definition of RN , and further upper bounding (Lemma 7) yields
RN ≤ min
( (2K + 1)Nex
N ,
(2K + 1) ( 288 (K/∆)2 ln(4KNex/δ) + 1 ) N ) (9)
Finally, we consider the case in which the test at line 6 is false for all tasks n ≤ Nex, and line 7 is executed with CNex+1 containing two or more policies. This is covered by a worst case explorethen-commit analysis. The key idea here is to use the definition of k′ in Equation (7) to lower bound reward(πk′) in terms of reward(πk?)/cost(πk?). This, together with some additional technical estimations (Lemma 8) leads to the result.
As we mentioned in Footnote 4, if we swap the bounds on durations τk ≤ k with generic τk ≤ Dk (with k 7→ Dk non-decreasing), the result would still hold, but the right-hand side would scale with DK rather than K. To see why, note that in our current presentation when the policy set Π is finite, K plays the role of both the cardinality of Π and a uniform upper bound on their durations, where the latter role is the most important. The key intuition on why this is the case is that whenever some data are sufficient to evaluate a policy k, it can also be used to evaluate all policies k′ ≤ k for free. In particular, in a case where many (even infinitely many, in principle) of the durations of the policies shared the same upper bound Dk, our algorithm would have a very easy time in narrowing down the best one because, using only Dk samples, it could keep updated a large number of policy estimators all at once.

heading: 5 Competing Against Infinitely Many Policies (ESC-CAPE)
text: Theorem 1 provides theoretical guarantees on the convergence rate RN of CAPE to the best ROI of a finite set of policies. Unfortunately, the bound becomes vacuous when the cardinality K of the policy set is large compared to the number of tasks N . It is therefore natural to investigate whether the problem becomes impossible in this scenario. Infinite sets of policies. With this goal in mind, we now focus on policy sets Π = {πk}k∈K ={ (τk, accept) } k∈K as in the previous section, with K = N rather than K = {1, . . . ,K}.
We will show how such a countable set of policies can be reduced to a finite one containing all optimal policies with high probability (Algorithm 2, ESC). After this is done, we can run CAPE on the smaller policy set, obtaining theoretical guarantees for the resulting algorithm.
Estimating rewards and costs. Similarly to eqs. (5) and (6), we first introduce estimators for our target quantities. If at least 2k samples are drawn during each of n2 consecutive tasks n1 + 1, . . . , n1 + n2, we can define, for all ε > 0, the following lower confidence bound on reward(πk):
r̂−k (n1, n2, ε) = 1
n2 n1+n2∑ n=n1+1 k∑ i=1 Xn,k+i k accept ( τk(Xn),Xn ) − 2ε (10)
If at least τk(Xn) samples are drawn during each of m0 consecutive tasks n0 + 1, . . . , n0 +m0, we can define the following empirical average of cost(πk):
ck(n0,m0) = ( τk(Xn0+1) + . . .+ τk(Xn0+m0) ) /m0 (11)
A key observation. The key idea behind Algorithm 2 (ESC) is simple. Since all optimal policies πk? have to satisfy the relationships reward(πk)/cost(πk) ≤ reward(πk?)/cost(πk?) ≤ 1/cost(πk?), then, for all policies πk with positive reward(πk), the cost of any optimal policy πk? must satisfy the relationship cost(πk?) ≤ cost(πk)/reward(πk). In other words, optimal policies cannot draw too many samples and their cost can be controlled by estimating the reward and cost of any policy with positive reward.
We recall that running a policy (τ, 0) during a task n means drawing the first τ(Xn) samples of Xn = (Xn,1, Xn,2, . . .) and always rejecting µn, regardless of the observations.
Algorithm 2: Extension to Countable (ESC) Input: countable policy set Π, number of tasks N , confidence parameter δ, accuracy levels (εn)n Initialization: for all j, let mj ← ⌈ ln ( j(j + 1)/δ ) /2ε2j ⌉ and Mj = m1 + . . .+mj
1 for j = 1, 2, . . . do 2 run policy ( 2 · 2j , 0 ) for mj tasks and compute r̂−2j ← r̂ − 2j (Mj−1,mj , εj) as in (10) 3 if r̂−2j > 0 then let j0 ← j and k0 ← 2 j0 4 for l = j0 + 1, j0 + 2, . . . do 5 run policy ( τ2l , 0 ) for ml tasks and compute c2l ← c2l(Ml−1,ml) as in (11) 6 if c2l > 2l εl + k0/r̂−k0 then let j1 ← l and return K ← 2 j1
Thus, Algorithm 2 (ESC) first finds a policy πk0 with reward(πk0) > 0 (lines 1–3), memorizing an upper estimate k0/r̂−k0 of the ratio cost(πk0)/reward(πk0) = 1/ROI(πk0). By the argument above, this estimate upper bounds the expected number of samples cost(πk?) drawn by all optimal policies πk? . Then ESC simply proceeds to finding the smallest (up to a factor of 2) K such that cost(πK) ≥ k0/r̂−k0 (lines 4–6). Being k0/r̂ − k0 ≥ cost(πk0)/reward(πk0) ≥ cost(πk?) by construction, the index K determined this way upper bounds k? for all optimal policies πk? . (All the previous statements are intended to hold with high probability.) This is formalized in the following key lemma, whose full proof we defer to Section C of the Supplementary Material.
Lemma 2. Let Π be a countable set of policies. If ESC is run with δ ∈ (0, 1), ε1, ε2, . . . ∈ (0, 1], and halts returning K, then k? ≤ K for all optimal policies πk? with probability at least 1− δ. Before proceeding with the main result of this section, we need a final lemma upper bounding the expected cost of our ESC algorithm. This step is crucial to control the total ROI because in this setting with arbitrarily long durations, picking the wrong policy even once is, in general, enough to drop the performance of an algorithm down to essentially zero, compromising the convergence to an optimal policy. This is another striking difference with other common online learning settings like stochastic bandits, where a single round has a negligible influence on the overall performance of an algorithm. To circumvent this issue, we designed ESC so that it tests shorter durations first, stopping as soon as the previous lemma applies, and a finite upper bound K on k? is determined.
Lemma 3. Let Π be a countable set of policies. If ESC is run with δ ∈ (0, 1), ε1, ε2, . . . ∈ (0, 1], and halts returning K, then the total number of samples it draws before stopping (i.e., its cost) is upper bounded by Õ ( (K/ε2) log(1/δ) ) , where ε = min{ε1, ε2, . . . , εlog2K}.
Proof. Note that, by definition, ε = min{ε1, ε2, . . . , εj1} > 0. Algorithm 2 (ESC) draw samples only when lines 2 or 5 are executed. Whenever line 2 is executed (j = 1, . . . , j0) the algorithm performs mj tasks drawing 2 · 2j samples each time. Similarly, whenever line 5 is executed (l = j0 + 1, . . . , j1) the algorithm draws at most 2l samples during each of the ml tasks. Therefore, recalling that j1 = log2K, the total number of samples drawn by ESC before stopping is at most
j0∑ j=1 2 · 2jmj + j1∑
l=j0+1
2lml ≤ 2 j1∑ j=1 2jmj ≤ 2j12j1 ⌈ 1 2ε2 ln j1(j1 + 1) δ ⌉
The ESC-CAPE algorithm. We can now join together our two algorithms obtaining a new one, that we call ESC-CAPE, which takes as input a countable policy set Π, the number of tasks N , a confidence parameter δ, some accuracy levels ε1, ε2, . . ., and an exploration cap Nex. The joint
algorithm runs ESC first with parameters Π, N, δ, ε1, ε2, . . .. Then, if ESC halts returning K, it runs CAPE with parameters {(τk, accept)}k∈{1,...,K} , N, δ,Nex.
Analysis of ESC-CAPE. Since ESC rejects all values µn, the sum of the rewards accumulated during its run is zero. Thus, the only effect that ESC has on the convergence rate RN of ESC-CAPE is an increment on the total cost in the denominator of its ROI. We control this cost by minimizing its upper bound in Lemma 3. This is not a simple matter of taking all εj’s as large as possible. Indeed, if all the εj’s are large, the if clause at line 3 might never be verified, because the conditional checks whether a confidence interval (for reward(π2j )) of length Θ(ε) sits to the right of the origin. In other words, the returned index K depends on ε and grows unbounded in general as ε approaches 1/2. This follows directly from the definition of our lower estimate on the rewards (10). Thus, there is a trade-off between having a small K (which requires small εj’s) and a small 1/ε2 to control the cost of ESC (for which we need large εj’s). A direct computation shows that picking constant accuracy levels εj = N−1/3 for all j achieves the best of both worlds and immediately gives our final result.
Theorem 4. If Π is a countable set of policies, then the ROI of ESC-CAPE run for N tasks with confidence parameter δ ∈ (0, 1), constant accuracy levels εj = N−1/3, and exploration cap Nex = ⌈ N2/3 ⌉ converges to the optimal ROI(πk?), with probability at least 1− δ, at a rate
RN = Õ (
1 +KI{ESC halts returning K} N1/3 ) where the Õ notation hides only logarithmic terms, including a log(1/δ) term. Note that the previous bound depends on the algorithm-dependent quantity K. While this might seem somewhat nonconventional, a simple argument gets rid of this issue. Indeed, if a lower bound λ? on the ROI of an optimal policy were known beforehand, then it would be easy to control K by estimating the cost of policies 2`, for increasing values of ` (as in ESC). In this case, K would be upper bounded by the number of policies whose cost is smaller than 2/λ? (say). This quantity is now constant (in N ; it depends only on the distribution D and the set of policies Π, playing the role of a complexity measure of the problem instance). If λ? is unknown, one can first estimate it up to some multiplicative constant (say, 1/2), with high probability. Again, we can do this at a constant cost (depending only on the instance (Π,D)) via a multiplicative Chernoff bound.

heading: 6 Conclusions
text: After formalizing the problem of ROI maximization in repeated decision making, we presented an algorithm (ESC-CAPE) that is competitive against infinitely large policy sets (Theorem 4). For this algorithm, we prove a convergence rate of order 1/N1/3 with high probability. To analyze it, we first proved a convergence result for its finite counterpart CAPE (Theorem 1), which is of independent interest. Notably, this finite analysis guarantees a significantly faster convergence of order 1/N on easier instances in which there is a positive gap in performance between the two best policies.
Acknowledgments and Disclosure of Funding An earlier version of this work was done during Tommaso Cesari’s Ph.D. at the University of Milan. Nicolò Cesa-Bianchi and Tommaso R. Cesari gratefully acknowledge partial support by Criteo AI Lab through a Faculty Research Award and by the MIUR PRIN grant Algorithms, Games, and Digital Markets (ALGADIMAR). Nicolò Cesa-Bianchi was also supported by the COST Action CA16228 “European Network for Game Theory” (GAMENET) and by the EU Horizon 2020 ICT-48 research and innovation action under grant agreement 951847, project ELISE. This work has also benefited from the AI Interdisciplinary Institute ANITI. ANITI is funded by the French “Investing for the Future – PIA3” program under the Grant agreement n. ANR-19-PI3A-0004. Yishay Mansour was supported in part by a grant from the European Research Council (ERC) under the European Union’sHorizon 2020 research and innovation program (grant agreement No. 882396), by the Israel Science Foundation(grant number 993/17), Tel Aviv University Center for AI and Data Science (TAD), and the Yandex Initiative for Machine Learning at Tel Aviv University. Vianney Perchet was supported by a public grant as part of the Investissement d’avenir project, reference ANR-11-LABX0056-LMH, LabEx LMH, in a joint call with Gaspard Monge Program for optimization, operations research and their interactions with data sciences. Vianney Perchet also acknowledges the support of the ANR under the grant ANR-19-CE23-0026.

Review summaries:
Paper considers a return on investment problem. On round n a task arrives parameterized by a mean parameter mu_n. The learner can observe realizations X_{n} := (X_{n,1},X_{n,2},…) where each is a random variable with mean mu_n as many times as she likes. She uses a policy pi that defines a stopping time tau(X_n) that decides when to stop observing the sequence and then outputs a decision accept(X_n) in {0,1}. The RIO is defined as E[ sum_{n=1}^N mu_n accept(X_n) ] / sum_{n=1}^N E[ tau(X_n) ]. Given a finite set of policies, one can consider the regret as the difference between the optimal policy and the sequence of policies executed by the learner.  A somewhat arbitrary set of policies is considered, with the sole restriction that the kth policy pi_k := (tau_k, accept_k) satisfies tau_k(X_n) <= k almost surely, for all k in a finite set or the natural numbers. The countable set case follows by finding an upper bound K on k*, the index of the optimal policy, and then running their finite set algorithm over K policies.   In the finite setting, if K = O(N^(1/3)) then their regret goes down like K/N^{1/3}. In the countable setting, the regret also scales like this, where now “K” is a random variable returned by their algorithm.

This paper considers a sequential decision process that models that of ideation. At any time an agent has access to a reward distribution and they can either take a sample from the distribution, accept the distribution and receive a reward equivalent to the mean of the distribution, or reject the distribution and receive the reward of 0. The goal of the agent is to find a policy that maximizes their expected ROI, that is the ratio of the total reward of their policies over the total cost (expected number of samples a policy takes).

This paper studies the problem of Return On Investment (ROI) maximization in repeated decision-making. The main contributions are as follows.  The authors first propose a framework for ROI maximization in Sec. 3. The main contribution here is to formulate an objective/regret in Eq. (2), which is a ratio of reward over cost. The problem is then to maximize the average reward-cost ratio of $N$ tasks, where each task's value is an i.i.d. sample from a true $\mu$.  When the policy class is finite with $K > 0$ policies, the authors propose the Capped Policy Elimination (CAPE) in Algorithm 1, and show that its convergence rate is $\tilde{O}(1/N^{1/3})$ in Theorem 1. The main idea is to make a decision first, then use oversampling to get i.i.d. samples of the reward and cost, and then use concentration inequality to estimate the performance gap $\Delta$ of policies to do policy elimination.  When the policy class is countably infinite, the authors propose the : Extension to Countable (ESC) in Algorithm 2 to reduce the policy class to finite. The main idea is to estimate the upper bound of the optimal policy's cost, such that any optimal policy would take smaller number of observations. Then CAPE is used on the reduced policy class, and a similar $\tilde{O}(1/N^{1/3})$ convergence rate upper bound is shown in Theorem 4.