Year: 2021

Abstract:
Thanks to the power of representation learning, neural contextual bandit algorithms demonstrate remarkable performance improvement against their classical counterparts. But because their exploration has to be performed in the entire neural network parameter space to obtain nearly optimal regret, the resulting computational cost is prohibitively high. We perturb the rewards when updating the neural network to eliminate the need of explicit exploration and the corresponding computational overhead. We prove that a Õ(d̃ √ T ) regret upper bound is still achievable under standard regularity conditions, where T is the number of rounds of interactions and d̃ is the effective dimension of a neural tangent kernel matrix. Extensive comparisons with several benchmark contextual bandit algorithms, including two recent neural contextual bandit models, demonstrate the effectiveness and computational efficiency of our proposed neural bandit algorithm.

text: √ T ) regret upper bound is still
achievable under standard regularity conditions, where T is the number of rounds of interactions and d̃ is the effective dimension of a neural tangent kernel matrix. Extensive comparisons with several benchmark contextual bandit algorithms, including two recent neural contextual bandit models, demonstrate the effectiveness and computational efficiency of our proposed neural bandit algorithm.

heading: 1 INTRODUCTION
text: Contextual bandit is a well-formulated abstraction of many important real-world problems, including content recommendation (Li et al., 2010; Wu et al., 2016), online advertising (Schwartz et al., 2017; Nuara et al., 2018), and mobile health (Lei et al., 2017; Tewari & Murphy, 2017). In such problems, an agent iteratively interacts with an environment to maximize its accumulated rewards over time. Its essence is sequential decision-making under uncertainty. Because the reward from the environment for a chosen action (also referred to as an arm in literature) under each context is stochastic, a no-regret learning algorithm needs to explore the problem space for improved reward estimation, i.e., learning the mapping from an arm and its context1 to the expected reward.
Linear contextual bandit algorithms (Abbasi-Yadkori et al., 2011; Li et al., 2010), which assume the reward mapping is a linear function of the context vector, dominate the community’s attention in the study of contextual bandits. Though theoretically sound and practically effective, their linear reward mapping assumption is incompetent to capture possible complex non-linear relations between the context vector and reward. This motivated the extended studies in parametric bandits, such as generalized linear bandits (Filippi et al., 2010; Faury et al., 2020) and kernelized bandits (Chowdhury & Gopalan, 2017; Krause & Ong, 2011). Recently, to unleash the power of representation learning, deep neural networks (DNN) have also been introduced to learn the underlying reward mapping directly. In (Zahavy & Mannor, 2019; Riquelme et al., 2018; Xu et al., 2020), a deep neural network is applied to provide a feature mapping, and exploration is performed at the last layer. NeuralUCB (Zhou et al., 2020) and NeuralTS (Zhang et al., 2020) explore the entire neural network parameter space to obtain nearly optimal regret using the neural tangent kernel technique (Jacot et al., 2018). These neural contextual bandit algorithms significantly boosted empirical performance compared to their classical counterparts.
Nevertheless, a major practical concern of existing neural contextual bandit algorithms is their added computational cost when performing exploration. Take the recently developed NeuralUCB and NeuralTS for example. Their construction of the high-probability confidence set for model exploration depends on the dimensionality of the network parameters and the learned context vectors’ representations, which is often very large for DNNs. For instance, a performing neural bandit solution often has the number of parameters in the order of 100 thousands (if not less). It is prohibitively
1When no ambiguity is invoked, we refer to the feature vector for an arm and its context as a context vector.
expensive to compute inverse of the induced covariance matrix on such a huge number of parameters, as required by their construction of confidence set. As a result, approximations, e.g., only using the diagonal of the covariance matrix (Zhou et al., 2020; Zhang et al., 2020), are employed to make such algorithms operational in practice. But there is no theoretical guarantee for such diagonal approximations, which directly leads to the gap between the theoretical and empirical performance of the neural bandit algorithms.
In this work, to alleviate the computational overhead caused by the expensive exploration, we propose to eliminate explicit model exploration by learning a neural bandit model with perturbed rewards. At each round of model update, we inject pseudo noise generated from a zero-mean Gaussian distribution to the observed reward history. With the induced randomization, sufficient exploration is achieved when simply pulling the arm with the highest estimated reward. This brings in considerable advantage over existing neural bandit algorithms: no additional computational cost is needed to obtain no regret. We rigorously prove that with a high probability the algorithm obtains a Õ(d̃ √ T )
regret, where d̃ is the effective dimension of a neural tangent kernel matrix and T is the number of rounds of interactions. This result recovers existing regret bounds for the linear setting where the effective dimension equals to the input feature dimension. Besides, our extensive empirical evaluations demonstrate the strong advantage in efficiency and effectiveness of our solution against a rich set of state-of-the-art contextual bandit solutions over both synthetic and real-world datasets.

heading: 2 RELATED WORK
text: Most recently, attempts have been made to incorporate DNNs with contextual bandit algorithms. Several existing work study neural-linear bandits (Riquelme et al., 2018; Zahavy & Mannor, 2019), where exploration is performed on the last layer of the DNN. Under the neural tangent kernel (NTK) framework (Jacot et al., 2018), NeuralUCB (Zhou et al., 2020) constructs confidence sets with DNN-based random feature mappings to perform upper confidence bound based exploration. NeuralTS (Zhang et al., 2020) samples from the posterior distribution constructed with a similar technique. However, as the exploration is performed in the induced random feature space, the added computational overhead is prohibitively high, which makes such solutions impractical. The authors suggested diagonal approximations of the resulting covariance matrix, which however leave the promised theoretical guarantees of those algorithms up in the air.
Reward perturbation based exploration has been studied in a number of classical bandit models (Kveton et al., 2019a; 2020; 2019b). In a context-free k-armed bandit setting, Kveton et al. (2019b) proposed to estimate each arm’s reward over a perturbed history and select the arm with the highest estimated reward at each round. Such an arm selection strategy is proved to be optimistic with a sufficiently high probability. Later this strategy has been extended to linear and generalized linear bandits (Kveton et al., 2019a; 2020). In (Kveton et al., 2020), the authors suggested its application to neural network models; but only some simple empirical evaluations were provided, without any theoretical justifications. Our work for the first time provides a rigorous regret analysis of neural contextual bandits with the perturbation-based exploration: a sublinear regret bound is still achievable in terms of the number of interactions between the agent and environment.

heading: 3 NEURAL BANDIT LEARNING WITH PERTURBED REWARDS
text: We study the problem of contextual bandit with finite K arms, where each arm is associated with a d-dimensional context vector: xi ∈ Rd for i ∈ [K]. At each round t ∈ [T ], the agent needs to select one of the arms, denoted as at, and receives its reward rat,t, which is generated as rat,t = h(xat) + ηt. In particular, h(x) represents the unknown underlying reward mapping function satisfying 0 ≤ h(x) ≤ 1 for any x, and ηt is an R-sub-Gaussian random variable that satisfies E[exp(µηt)] ≤ exp[µ2R2] for all µ ≥ 0. The goal is to minimize pseudo regret over T rounds:
RT = E [∑T
t=1 (ra∗ − rt,at)
] , (3.1)
where a∗ is the optimal arm with the maximum expected reward.
To deal with the potential non-linearity of h(x) and unleash the representation learning power of DNNs, we adopt a fully connected neural network f(x;θ) to approximate h(x): f(x;θ) =
Algorithm 1 Neural bandit with perturbed reward (NPR) 1: Input: Number of rounds T , regularization coefficient λ, perturbation parameter ν, network
width m, network depth L. 2: Initialization: θ0 = (vec(W1), . . . , vec(WL)] ∈ Rp with Gaussian distribution: for 1 ≤ l ≤ L − 1, Wl = (W, 0; 0,W) with each entry of W sampled independently from N (0, 4/m); WL = (w
>,−w>) with each entry of w sampled independently from N (0, 2/m). 3: for t = 1, . . . , T do 4: if t > K then 5: Pull arm at and receive reward rt,at , where at = argmaxi∈[K] f(xi,θt−1). 6: Generate {γts}s∈[t] ∼ N (0, ν2). 7: Set θt by the output of gradient descent for solving Eq (3.2). 8: else 9: Pull arm ak.
10: end if 11: end for
√ mWLφ ( WL−1φ ( · · ·φ(W1x) )) , where φ(x) = ReLU(x), θ = [vec(W1), . . . , vec(WL)] ∈
Rp with p = m + md + m2(L − 1), and depth L ≥ 2. Each hidden layer is assumed to have the same width (i.e., m) for convenience in later analysis; but this does not affect the conclusion of our theoretical analysis.
Existing neural bandit solutions perform explicit exploration in the entire model space (Zhou et al., 2020; Zhang et al., 2020; Zahavy & Mannor, 2019; Riquelme et al., 2018; Xu et al., 2020), which introduces prohibitive computational cost. And oftentimes the overhead is so high that approximation has to be employed (Zhou et al., 2020; Zhang et al., 2020), which unfortunately breaks the theoretical promise of these algorithms. In our proposed model, to eliminate such explicit model exploration in neural bandit, a randomization strategy is introduced in the neural network update. We name the resulting solution as Neural bandit with Perturbed Rewards, or NPR in short. In NPR, at round t, the neural model is learned with the t rewards perturbed with designed perturbations:
min θ L(θ) = ∑t s=1 ( f(xas ;θ)− (rs,as + γts) )2 /2 +mλ‖θ − θ0‖22/2 (3.2)
where {γts}ts=1 ∼ N (0, ν2) are Gaussian random variables that are independently sampled in each round t, and ν is a hyper-parameter that controls the strength of perturbation (and thus the exploration) in NPR. We use an l2-regularized square loss for model estimation, where the regularization centers at the randomly initialization θ0 with the trade-off parameter λ.
The detailed procedure of NPR is given in Algorithm 1. The algorithm starts by pulling all candidate arms once. This guarantees that for any arm, NPR is sufficiently optimistic compared to the true reward with respect to its approximation error (Lemma 4.4). When all the K arms have been pulled once, the algorithm pulls the arm with the highest estimated reward, at = argmaxi f(xi;θt−1). Once received the feedback rat,t, the model perturbs the entire reward history so far via a freshly sampled noise sequence {γts}ts=1, and updates the neural network by {(xas , ras,s + γts)}ts=1 using gradient descent. In the regret analysis in Section 4, we prove that the variance from the added {γts}s∈[t] will lead to the necessary optimism for exploration (Abbasi-Yadkori et al., 2011). We adopt gradient descent for analysis convenience, while stochastic gradient descent can also be used to solve the optimization problem with a similar theoretical guarantee based on recent works (AllenZhu et al., 2019; Zou et al., 2019).
Compared with existing neural contextual bandit algorithms (Zhou et al., 2020; Zhang et al., 2020; Zahavy & Mannor, 2019; Riquelme et al., 2018; Xu et al., 2020), NPR does not need any added computation for model exploration, besides the regular neural network update. This greatly alleviates the overhead for the computation resources (both space and time) and makes NPR sufficiently general to be applied for practical problems. More importantly, our theoretical analysis directly corresponds to its actual behavior when applied, as no approximation is needed.

heading: 4 REGRET ANALYSIS
text: In this section, we provide finite time regret analysis of NPR, where the time horizon T is set beforehand. The theoretical analysis is built on the recent studies about the generalization of DNN models (Cao & Gu, 2020; 2019; Chen et al., 2019; Daniely, 2017; Arora et al., 2019), which illustrate that with (stochastic) gradient descent, the learned parameters of a DNN locate in a particular regime with the generalization error being characterized by the best function in the corresponding neural tangent kernel (NTK) space (Jacot et al., 2018). We leave the background of NTK in the appendix and focus on the key steps of our proof in this section.
The analysis starts with the following lemma for the set of context vectors {xi}Ki=1. Lemma 4.1. There exists a positive constant C̄ such that for any δ ∈ (0, 1), when m ≥ C̄K4L6 log(K2L/δ)/λ40, with probability at least 1− δ, there exists a θ∗ ∈ Rp, for all i ∈ [K],
h(xi) = 〈g(xi;θ0),θ∗ − θ0〉, √ m‖θ∗ − θ0‖2 ≤ √ 2h>H−1h, (4.1)
where H is the NTK matrix defined on the context set and h = (h(x1), . . . , h(xK)). Details of H can be found in the appendix.
This lemma suggests that with a satisfied neural network width m, with high probability, the underlying reward mapping function can be approximated by a linear function over g(xi;θ0), parameterized by θ∗ − θ0, where g(xi;θ0) = ∇θf(x;θ0) ∈ Rd is the gradient of the initial neural network. We also define the covariance matrix At at round t as,
At = ∑t−1
s=1 g(xs,as ;θ0)g(xs,as ;θ0)
>/m+ λI (4.2)
where λ > 0 is the l2 regularization parameter in Eq (3.2). Discussed before, there exist two kinds of noises in the training samples: the observation noise and the perturbation noise. To analyze the effect of each noise in model estimation, two auxiliary least square solutions are introduced, A−1t b̄t and A−1t bt with
b̄t = ∑t−1
s=1 (rs,as + E[γt−1s ])g(xs,as ;θ0)/
√ m, bt = ∑t−1 s=1 (rs,as + γ t−1 s )g(xs,as ;θ0)/ √ m.
These two auxiliary solutions isolate the induced deviations: the first least square solution only contains the deviation caused by observation noise {ηs}t−1s=1; and the second least square solution has an extra deviation caused by {γt−1s }t−1s=1. To analysis the estimation error of the neural network, we first define the following events. At round t, we have event Et,1 defined as:
Et,1 = { ∀i ∈ [K], |〈g(xt,i;θ0),A−1t b̄t/ √ m〉 − h(xt,i)| ≤ αt‖g(xt,i;θ0)‖A−1t } .
According to Lemma 4.1 and the definition of b̄t, under event Et,1, the deviation caused by the observation noise {ηs}t−1s=1 can be controlled by αt. We also need event Et,2 at round t defined as
Et,2 = {∀i ∈ [K] : |f(xt,i;θt−1)− 〈g(xt,i;θ0),A−1t b̄t/ √ m〉| ≤ (m) + βt‖g(xt,i;θ0)‖A−1t },
where (m) is defined as
(m) =C ,1m −1/6T 2/3λ−2/3L3 √ logm+ C ,2(1− ηmλ)J √ TL/λ
+ C ,3m −1/6T 5/3λ−5/3L4 √ logm(1 + √ T/λ),
with constants {C ,i}3i=1. Event Et,2 considers the situation that the deviation caused by the added noise {γt−1s }t−1s=1 is under control with parameter βt at round t, and the approximation error (m) is carefully tracked by properly setting the neural network width m.
Next, the following lemmas show that with proper setting, given the history Ft−1 = σ{x1, r1,x2, r2, . . . ,xt−1, rt−1,xt}, which is σ-algebra generated by the previously pulled arms and the observed rewards, events Et,1 and Et,2 happen with a high probability.
Lemma 4.2. For any t ∈ [T ], λ > 0 and δ > 0, with αt = √ R2 log ( det(At)/(δ2 det(λI)) ) + √ λS, we have P(Et,1|Ft−1) ≥ 1− δ.
In particular, S denotes the upper bound of √
2h>H−1h, which is a constant if the reward function h(·) belongs to the RKHS space induced by the neural tangent kernel. Lemma 4.3. There exist positive constants {Ci}3i=1, such that with step size and the neural network satisfy that η = C1(mλ+mLT )−1,m ≥ C2 √ λL−3/2[log(TKL2/δ)]3/2, andm[logm]−3 ≥
C3 max{TL12λ−1, T 7λ−8L18(λ+LT )6, L21T 7λ−7(1+ √ T/λ)6}, given history Ft−1, by choosing βt = σ √ 4 log t+ 2 logK, we have P(Et,2|Ft−1) ≥ 1− t−2.
We leave the detailed proof in the appendix. According to Lemma 4.2 and Lemma 4.3, with more observations become available, the neural network based reward estimator f(x;θt) will gradually converge to the true expected reward h(x). In the meantime, the variance of the added perturbation leads to reward overestimation, which will compensate the potential underestimation caused by the observation noise and the approximation error. The following lemma describes this anticoncentration behavior of the added noise {γt−1s }t−1s=1. Lemma 4.4. For any t ∈ [T ], with ν = αt(1 − λλ−1K (AK))−1/2, αt defined in Lemma 4.2, (m) defined in Lemma 4.3, given history Ft−1, we have P ( Et,3) = P(f(xt,i;θt−1) ≥ h(xt,i) −
(m)|Ft−1, Et,1 ) ≥ (4e √ π)−1, where AK is the covariance matrix constructed after the initial K-round arm pulling (line 8 to 10 in Algorithm 1) by Eq (4.2), and λK(AK) represents the K-th largest eigenvalue of matrix AK .
With αt defined in Lemma 4.2, and (m) and βt defined in Lemma 4.3, we divide the arms into two groups. More specifically, we define the set of sufficiently sampled arms in round t as:
Ωt = {∀i ∈ [K] : 2 (m) + (αt + βt)‖g(xt,i;θ0)‖A−1t ≤ h(xt,a∗)− h(xt,i)}.
Accordingly, the set of undersampled arms is defined as Ω̄t = [K] \Ωt. Note that by this definition, the best arm a∗ belongs to Ω̄t. In the following lemma, we show that at any time step t > K, the expected one-step regret is upper bounded in terms of the regret due to playing an undersampled arm at ∈ Ω̄t. Lemma 4.5. With m, η, ν satisfying the conditions in Lemma 4.2, 4.3, 4.4, and (m) defined in Lemma 4.3, with probability at least 1− δ the one step regret of NPR is upper bounded, E[h(xt,a∗t )− h(xt,at)] ≤ P(Ēt,2) + 4 (m) + (βt + αt) ( 1 + 2/P(at ∈ Ω̄t) ) ‖g(xt,at ;θ0)/ √ m‖A−1t .
Furthermore, P(at ∈ Ω̄t) ≥ Pt(Et,3)− Pt(Ēt,2).
To bound the cumulative regret of NPR, we also need the following lemma.
Lemma 4.6. With d̃ as the effective dimension of the NTK matrix H, we have∑T t=1 min { ‖g(xt,at ;θ0)/ √ m‖2 A−1t−1 , 1 } ≤ 2(d̃ log(1 + TK/λ) + 1)
The effective dimension is first proposed in (Valko et al., 2013) to analyze the kernelized contextual bandit, which roughly measures the number of directions in the kernel space where the data mostly lies. The detailed definiton of d̃ can be found in Definition B.3 in the appendix. Finally, with proper neural network setup, we provide an m-independent regret upper bound.
Theorem 4.7. Let d̃ be the effective dimension of the NTK kernel matrix H. There exist positive constants C1 and Cr, such that for any δ ∈ (0, 1), when network structure and the step size for model update satisfy m ≥ poly(T, L,K, λ−1, S−1, log(1/δ)), η = C1(mTL + mλ)−1 and λ ≥ max{1, S−2}, with probability at least 1− δ, the cumulative regret of NPR satisfies
RT ≤ Γ ( R √ d̃ log(1 + TK/λ) + 2− 2 log δ + √ λS ) · √ 2d̃T log(1 + TK/λ) + 2 + 7 +K
(4.3)
where Γ = 44e √ π(1 + √ (4 log T + 2 logK)/(1− λλ−1K (AK))).
Proof. By Lemma 4.2, Et,1 holds for all t ∈ [T ] with probability at least 1 − δ. Therefore, with probability at least 1− δ, we have
RT = T∑ t=1 E[(h(xt,a∗t )− h(xt,at))1{Et,1}] ≤ T∑ t=K+1 E[(h(xt,a∗t )− h(xt,at))1{Et,1}] +K
≤4T (m) + T∑ t=1 Pt(Ēt,2) + (βt + αt)(1 + 2 Pt(Et,3)− Pt(Ēt,2) )‖g(xt,at ;θ0)/ √ m‖A−1t +K.
The second inequality is due to the analysis of one-step regret in Lemma 4.5. According to Lemma 4.3, by choosing δ = σct, with ct = √ 4 log t+ 2 logK, Pt(Ēt,2) ≤ t−2. Hence, ∑T t=1 Pt(Ēt,2) ≤ π2/6. Based on Lemma 4.4, with σ = αt(1 − λλ−1K (AK))−1/2, Pt(Et,3) ≥ 1 4e √ π
. Therefore, 1 + 2/(Pt(Et,3)− Pt(Ēt,2)) ≤ 44e √ π. By chaining all the inequalities, we have the cumulative regret of NPR upper bounded as,
RT ≤ π2
3 + 4T (m) + ∑T t=1 (βt + αt)(1 + 2 Pt(Et,3)− Pt(Ēt,2) )‖g(xt,at ;θ0)/ √ m‖A−1t +K
≤Γ ( R √ d̃ log(1 + TK/λ) + 2− 2 log δ + √ λS ) · √ 2d̃T log(1 + TK/λ) + 2 + π2
3 +K
+ C ,1m −1/6T 5/3λ−2/3L3 √ logm+ C ,2(1− ηmλ)JT √ TL/λ
+ C ,3m −1/6T 8/3λ−5/3L4 √ logm(1 + √ T/λ)
where Γ = 44e √ π(1 + √ (4 log T + 2 logK)/(1− λλ−1K (AK))). The second inequality is due to Lemma 4.6, and the bounds of events Ēt,2 and Et,3. By setting η = c(mλ + mLT )−1, and J = (1+LT/λ)(log(C ,2)+log T √ TL/λ)/c, C ,2(1−ηmλ)JT √ TL/λ ≤ 1. Then by choosing the satisfiedm, C ,1m−1/6T 5/3λ−2/3L3 √ logm+C ,3m −1/6T 8/3λ−5/3L4 √ logm(1+ √ T/λ) ≤
2/3. RT can be further bounded by RT ≤ Γ ( R √ d̃ log(1 + TK/λ) + 2− 2 log δ + √ λS ) ·√
2d̃T log(1 + TK/λ) + 2 + 7 +K
This completes the proof.

heading: 5 EXPERIMENTS
text: In this section, we empirically evaluate the proposed neural bandit algorithm NPR against several state-of-the-art baselines, including: linear and neural UCB (LinUCB (Abbasi-Yadkori et al., 2011) and NeuralUCB (Zhou et al., 2020)), linear and neural Thompson Sampling (LinTS (Agrawal & Goyal, 2013) and NeuralTS (Zhang et al., 2020)), perturbed reward for linear bandits (LinFPL) (Kveton et al., 2019a). To demonstrate the real impact of using diagonal approximation in confidence set construction, we also include NeuralUCB and NeuralTS with diagonal approximation as suggested in their original papers for comparisons.
We evaluated all the algorithms on 1) synthetic dataset via simulation, 2) six K-class classification datasets from UCI machine learning repository (Beygelzimer et al., 2011), and 3) two real-world datasets extracted from the social bookmarking web service Delicious and music streaming service LastFM (Wu et al., 2016). We implemented all the algorithms in PyTorch and performed all the experiments on a server equipped with Intel Xeon Gold 6230 2.10GHz CPU, 128G RAM, four NVIDIA GeForce RTX 2080Ti graphical cards.

heading: 5.1 EXPERIMENT ON SYNTHETIC DATASET
text: In our simulation, we first generate a size-K arm pool, in which each arm i is associated with a d-dimensional feature vector xi. The contextual vectors are sampled uniformly at random from a unit ball. We generate the rewards via the following two nonlinear functions:
h1(x) = 10 −2(x>ΣΣ>x), h2(x) = exp(−10(x>θ)2) ,
where each element of Σ ∈ Rd×d is randomly sampled from N (0, 1), and θ is randomly sampled from a unit ball. At each round t, only a subset of k arms out of the totalK arms are sampled without replacement and disclosed to all algorithms for selection. The ground-truth reward ra is corrupted by Gaussian noise η = N (0, ξ2) before feeding back to the bandit algorithms. We fixed the feature dimension d = 50 and the pool size K = 100 with k = 20. ξ was set to 0.1 for both h1 and h2.
Cumulative regret is used to compare the performance of different algorithms. Here the best arm is defined as the one with the highest expected reward in the presented k candidate arms. All the algorithms were executed up to 10000 rounds in simulation, and the averaged results over 10 runs are reported in Figure 1(a) to 1(e). For the neural bandit algorithms, we adopted a 3-layer neural network with m = 64 units in each hidden layer. We did a grid search on the first 1000 rounds for regularization parameter λ over {10−i}4i=0, and step size η over {10−i}3i=0. We also searched for the concentration parameter δ so that the exploration parameter ν is equivalently searched over {10−i}4i=0. The best set of hyper-parameters for each algorithm are applied for the full simulation over 10000 rounds, i.e., only that trial will be continued for the rest of 9000 rounds.
In Figure 1(a) and 1(b), we can observe that linear bandit algorithms clearly failed to learn nonlinear mapping and suffered much higher regret compared to the neural algorithms. NPR achieved similar performance as NeuralUCB and NeuralTS, which shows the effectiveness of our randomized exploration strategy in neural bandit learning.
Figure 1(c) shows the average running time for all the neural bandit models in this experiment. With the same network structure, the time spent for model update was similar across different neural bandit models. But we can clearly observe that NeuralUCB and NeuralTS took much more time in arm selection. When choosing an arm, NeuralUCB and NeuralTS, and their corresponding versions with diagonal approximation, need to repeatedly compute: 1) the inverse of the covariance matrix based on the pulled arms in history; and 2) the confidence set of their reward estimation on each candidate arm. The size of the covariance matrix depends on the number of parameters in the neural network (e.g., 7460-by-7460 in this experiment). With diagonal approximation, the computational cost is significantly reduced. But, as mentioned before, there is no theoretical guarantee about the approximation’s impact on the model’s performance. Intuitively, the impact depends on how the full covariance matrix concentrates on its diagonal, e.g., whether the random feature mappings of the network on the pulled arms are correlated among their dimensions. Unfortunately, this cannot be determined in advance. Figure 1(a) and 1(b) show that the diagonal approximation leads to a significant performance drop. This confirms our concern of such an approximation. In contrast, as
shown in Figure 1(c), there is no extra computation overhead in NPR; in the meantime, it provides comparable performance to NeuralUCB and NeuralTS with a full covariance matrix.
To further investigate the efficiency advantage of NPR, we reported the total running time for the neural bandit algorithms under different sizes of the arm pool and different structures of the neural network under the same simulation setting. With the same neural network structure, models with different sizes of candidate arms should share the same running time for model update. Hence, Figure 1(d) reports how the size of arm pool affects the time spent on arm selection. As we can find, with more candidate arms, NeuralUCB, NeuralTS, and their corresponding diagonal approximations spent more time on arm selection, or more specifically on constructing the confidence set of the reward estimation for each arm. With a fixed size arm pool, the complexity of the neural network will strongly affect the time for computing the inverse of the covariance matrix. In Figure 1(e), the x-axis shows the structure for the hidden layers. The running time for NeuralUCB and NeuralTS significantly increased with enlarged neural networks. The running time of NPR stayed stable, across varying sizes of arm pools and the network complexity. This shows the strong advantage of NPR in efficiency and effectiveness, especially for large-scale problems.

heading: 5.2 EXPERIMENT ON CLASSIFICATION DATASETS
text: Following the setting in (Zhou et al., 2020), we evaluated the bandit algorithms on K-class classification problem with six public benchmark datasets, including adult, mushroom, and shuttle from UCI Machine Learning Repository (Dua & Graff, 2017). Due to space limit, we report the results on these three datasets in this section, and leave the other three, letter, covertype, and MagicTelescope in the appendix. We adopted the disjoint model (Li et al., 2010) to build the context vectors for candidate arms: given an input instance with feature x ∈ Rd of a k-class classification problem, we constructed the context features for k candidate arms as: x1 = (x,0, . . . ,0), . . . ,xk = (0, . . . ,0,x) ∈ Rd×k. The model receives reward 1 if it selects the correct class by pulling the corresponding arm, otherwise 0. The cumulative regret measures the total mistakes made by the model over T rounds. Similar to the experiment in synthetic datasets, we adopted a 3-layer neural network with m = 64 units in each hidden layer. We used the same grid search setting as in our experiments on synthetic datasets. Figure 2 shows the averaged results across 10 runs for 10000 rounds, except for mushroom which only contains 8124 data instances.
There are several key observations in Figure 2. First, the improvement of applying a neural bandit model depends on the nonlinearity of the dataset. For example, the performance on mushoom and shuttle was highly boosted by the neural models, while the improvement on adult was limited. Second, the impact of the diagonal approximation for NeuralUCB and NeuralTS also depends on the dataset. It did not hurt their performance too much on shuttle, while using the full covariance matrix led to much better performance on Mushroom. Overall, NPR showed consistently better or at least comparable performance to the best neural bandit baselines in all six datasets. Such robust performance and high efficiency make it more advantageous in practice.

heading: 5.3 EXPERIMENT ON LASTFM & DELICIOUS
text: The LastFM dataset was extracted from the music streaming service website Last.fm, and the Delicious data set was extracted from the social bookmark sharing service website Delicious (Wu et al., 2016). In particular, the LastFM dataset contains 1,892 users and 17,632 items (artists). We treat the “listened artists” in each user as positive feedback. The Delicious dataset contains 1,861 users and
69,226 items (URLs). We treat the bookmarked URLs for each user as positive feedback. Following the standard setting (Cesa-Bianchi et al., 2013), we pre-processed these two datasets. For the item features, we used all the tags associated with each item to create its TF-IDF feature vector. Then PCA was applied to reduce the dimensionality of the features. In both datasets, we used the first 25 principle components to construct the item feature vectors. On the user side, we created user features by running node2vec (Grover & Leskovec, 2016) on the user relation graph extracted from the social network provided by the datasets. Each of the users was represented with a 50-dimensional feature vector. We generated the candidate pool as follows: we fixed the size of candidate arm pool to k = 25 for each round; for each user, we picked one item from those non-zero payoff items according to the complete observations in the dataset, and randomly picked the other 24 from those zero-payoff items. We constructed the context vectors by concatenating the user and item feature vectors. In our experiment, a 3-layer neural network with m = 128 units in each hidden layer was applied to learn the bandit model. And the same gird search was performed to find the best set of hyper-parameters. We performed the experiment with 10000 rounds. Because of the high demand of GPU memory for the matrix inverse computation, we only compared NPR to NeuralUCB and NeuralTS with the diagonal approximation.
We compared the cumulative reward from each algorithm in Figure 3. Besides the neural contextual bandit algorithms, we also include the best reported model on these two datasets, hLinUCB (Wang et al., 2016) for comparison. To improve visibility, we normalized the cumulative reward by a random strategy’s cumulative reward (Wu et al., 2016), where the arm was randomly sampled from the candidate pool. All the neural models showed the power to learn the potential non-linear reward mapping on these two real-world datasets. NPR showed its advantage over the baselines (especially on LastFM). As NPR has no additional requirement on the computation resource (e.g., no need for the expensive matrix operation as in the baselines), we also experienced much shorter running in NPR than the other two neural bandit models.

heading: 6 CONCLUSION
text: Existing neural contextual bandit algorithms sacrifice computation efficiency for effective exploration in the entire neural network parameter space. To eliminate the computational overhead caused by such an expensive operation, we appealed to randomization-based exploration and obtained the same level of learning outcome. No extra computational cost or resources are needed besides the regular neural network update. We proved that the proposed solution obtains Õ(d̃ √ T ) regret for T rounds of interactions between the system and user. Extensive empirical results on both synthetic and real-world datasets support our theoretical analysis, and demonstrate the strong advantage of our model in efficiency and effectiveness, which suggest the potential of deploying powerful neural bandit model online in practice.
Our empirical efficiency analysis shows that the key bottleneck of learning a neural model online is at the model update step. Our current regret analysis depends on (stochastic) gradient descent over the entire training set for model update in each round, which is prohibitively expensive. We would like to investigate the possibility of more efficient model update, e.g., online stochastic gradient descent or continual learning, and the corresponding effect on model convergence and regret analysis.
Currently, our analysis focuses on the K-armed setting, and it is important to extend our solution and analysis to infinitely many arms in our future work.

Review summaries:
The paper considers a version of the stochastic contextual bandit where the underlying reward function is modelled by a deep neural network. This framework is useful for a number of complex problems where simpler parametric models of the reward are insufficient. The authors propose an algorithm inspired by the perturbed reward approaches of Kveton et al (2019a,b,2020) which ensures an exploration-exploitation balance by adding additional noise to the observed rewards. This approach avoids the inversion of large covariance matrices which existing approaches (NeuralUCB and NeuralTS) necessitate, and results in a computational speed-up while maintaining near-optimal regret guarantees.

The paper studies neural contextual bandits in the realizable setting. It proposes an algorithm that trains the neural network that maps arm contexts to rewards, with perturbed rewards. The paper proves that under NTK analysis the learnt function provides an optimistic estimate of the reward of each arms and therefore sub-linear regret guarantees can be derived. Crucially the dimension term in the regret only depends on the effective dimension of the NTK. Some experiments are performed on real and synthetic datasets where the proposed algorithm performs at par with neuralTS and neuralUCB algorithms while cutting down the running time by a large factor. Thus this can indicate the practicality of the proposed algorithm.

This paper addresses the reduction of computational cost of the neural contextual bandit problem which uses the deep neural networks to model the reward function. Existing works in this field often require the exploration of the entire neural network parameter space and thus, the computation cost is expensive, especially when the network is large. Their main contribution is to perturb the rewards when updating the network to eliminate the need for exploration. They showed that this idea works well in experiments while still maintaining the same regret bound rate as that of previous works in the NTK regime.